Membuat Aplikasi Keuangan Pribadi Menggunakan Python dan Django ( Tutorial Lengkap )
Java Script java HTML Python css

Membuat Aplikasi Keuangan Pribadi Menggunakan Python dan Django ( Tutorial Lengkap )
Admin
Admin
ID • 1 year ago • 62 min read • 6308 views
Membuat Aplikasi Keuangan Pribadi Menggunakan Python dan Django ( Tutorial Lengkap )

Membuat Aplikasi Keuangan Pribadi Menggunakan Python dan Django ( Tutorial Lengkap )

id • 62 min read • 6308 views

Membuat Aplikasi Keuangan Pribadi Menggunakan Python dan Django ( Tutorial Lengkap )

Dalam dunia yang semakin digital, manajemen keuangan pribadi menjadi salah satu keterampilan penting yang harus dikuasai oleh setiap individu. Dengan kemajuan teknologi, kita kini memiliki berbagai alat untuk membantu mengelola anggaran, melacak pengeluaran, dan merencanakan masa depan finansial kita. Salah satu cara untuk mempermudah proses ini adalah dengan menggunakan aplikasi keuangan pribadi. Aplikasi semacam ini tidak hanya membantu kita dalam mengelola keuangan sehari-hari, tetapi juga memberikan wawasan yang berharga tentang kebiasaan pengeluaran kita dan membantu kita mencapai tujuan finansial jangka panjang.

Dalam artikel ini, kita akan menjelajahi cara membangun aplikasi keuangan pribadi menggunakan dua alat powerful dalam pengembangan perangkat lunak: Python dan Django. Python, dengan sintaksisnya yang jelas dan kemampuannya yang luas, adalah bahasa pemrograman yang ideal untuk berbagai jenis aplikasi, dari analisis data hingga pengembangan web. Django, di sisi lain, adalah framework web yang dikembangkan untuk mempermudah proses pembuatan aplikasi web yang aman dan skalabel. Kombinasi Python dan Django memungkinkan kita untuk membangun aplikasi yang tidak hanya fungsional tetapi juga dapat dikembangkan lebih lanjut sesuai dengan kebutuhan pengguna.

Artikel ini akan memandu Anda melalui setiap langkah dalam proses pembuatan aplikasi keuangan pribadi, dimulai dari persiapan awal hingga deployment ke server. Kami akan membahas bagaimana cara menginstal Python dan Django, mengatur lingkungan pengembangan yang efektif, serta menggunakan alat dan pustaka tambahan untuk memperluas kemampuan aplikasi kita. Melalui panduan ini, Anda akan belajar cara merancang model data, membangun antarmuka pengguna, dan mengintegrasikan fitur-fitur canggih seperti API dan sistem autentikasi pengguna. Dengan mengikuti langkah-langkah yang kami sajikan, Anda akan memperoleh keterampilan dan pengetahuan yang diperlukan untuk mengembangkan aplikasi keuangan pribadi yang bisa membantu Anda atau orang lain dalam mengelola keuangan dengan lebih baik dan efektif.

Table of Contents

Persiapan Awal

Sebelum memulai pengembangan aplikasi keuangan pribadi menggunakan Python dan Django, ada beberapa langkah persiapan yang harus dilakukan untuk memastikan bahwa lingkungan pengembangan Anda siap dan alat yang diperlukan sudah tersedia. Bagian ini akan membahas secara rinci cara mengunduh dan menginstal Python, menyiapkan lingkungan pengembangan, serta menginstal pustaka tambahan yang diperlukan untuk proyek Anda.

 

2.1. Instalasi Python dan Django

Cara Mengunduh dan Menginstal Python

Python adalah bahasa pemrograman yang sangat populer dan serbaguna yang kita gunakan untuk membangun aplikasi web kita. Versi terbaru dari Python menyediakan berbagai fitur terbaru serta perbaikan bug yang memastikan kinerja optimal dan kompatibilitas dengan berbagai pustaka dan framework modern.

 

  1. Unduh Python

   Untuk memulai, Anda harus mengunduh Python dari situs resminya. Kunjungi [situs unduhan Python](https://www.python.org/downloads/). Di halaman ini, Anda akan melihat tombol Download Python di bagian atas halaman, yang biasanya menampilkan versi terbaru dari Python. Pilih versi Python yang sesuai dengan sistem operasi yang Anda gunakan, apakah itu Windows, macOS, atau Linux.

  •  Windows: Tekan tombol “Download Python X.X.X for Windows” (X.X.X adalah versi terbaru).
  •  macOS: Klik tombol “Download Python X.X.X for macOS”.
  •  Linux: Pengguna Linux dapat menggunakan pengelola paket distribusi mereka untuk menginstal Python atau mengunduh installer dari situs.

 

  1. Instal Python

   Setelah file installer diunduh, buka file tersebut untuk memulai proses instalasi. Pada jendela instalasi, pastikan untuk mencentang opsi “Add Python to PATH”. Ini adalah langkah penting karena menambahkan Python ke PATH memungkinkan Anda menjalankan perintah Python dari terminal atau command prompt.

   Klik "Install Now" untuk memulai proses instalasi. Installer akan melakukan semua langkah yang diperlukan untuk menginstal Python pada sistem Anda, termasuk menginstal pip, package manager untuk Python.

 

  1. Verifikasi Instalasi

   Setelah proses instalasi selesai, Anda perlu memverifikasi bahwa Python telah terinstal dengan benar. Buka terminal atau command prompt lalu jalankan perintah berikut:

   

```bash
   python --version
   ```

  

Jika instalasi berhasil, Anda akan melihat output yang menunjukkan versi Python yang baru diinstal, seperti `Python 3.10.2`.

   Selain itu, periksa bahwa pip telah terinstal dengan benar menggunakan perintah berikut:

 

```bash
   pip --version
   ```

  

   Anda seharusnya melihat versi pip yang terinstal, seperti `pip 21.3.1`.

 

Cara Menginstal Django Menggunakan Pip

Django adalah framework web yang akan Anda gunakan untuk membangun aplikasi keuangan pribadi. Django menawarkan berbagai fitur canggih yang mempermudah pengembangan aplikasi web, termasuk sistem routing URL, sistem model dan database, serta mekanisme autentikasi pengguna.

  1. Instal Django

   Dengan Python dan pip sudah terinstal, Anda sekarang dapat menginstal Django menggunakan pip. Buka terminal atau command prompt dan ketik perintah berikut:

  

```bash
   pip install django
   ```

 

   Perintah ini akan mengunduh dan menginstal Django serta semua dependensinya. Proses ini mungkin memerlukan beberapa menit tergantung pada kecepatan koneksi internet dan kecepatan komputer Anda.

 

  1. Verifikasi Instalasi Django

   Setelah Django terinstal, Anda harus memverifikasi bahwa instalasi berhasil dan Django terdeteksi dengan benar oleh sistem. Ketik perintah berikut di terminal atau command prompt:

 

```bash
   django-admin --version
   ```

   

   Jika Django telah terinstal dengan benar, Anda akan melihat output yang menunjukkan versi Django yang terinstal, misalnya `4.2.1`.

 

2.2. Pengaturan Lingkungan Pengembangan

Lingkungan pengembangan yang terisolasi adalah langkah penting dalam pengembangan perangkat lunak yang baik. Dengan menggunakan virtual environment, Anda dapat mengelola dependensi proyek Anda secara terpisah dari sistem Python global Anda, sehingga mencegah konflik antara paket-paket yang digunakan dalam berbagai proyek.

 

Membuat dan Mengaktifkan Virtual Environment

  1. Membuat Virtual Environment

   Virtual environment adalah lingkungan terpisah di dalam sistem Anda yang memiliki salinan terisolasi dari Python interpreter dan pustaka yang diinstal. Untuk membuat virtual environment, gunakan perintah berikut di terminal atau command prompt:

 

 ```bash
   python -m venv env
   ```

 

   Di sini, `env` adalah nama virtual environment yang akan Anda buat. Anda dapat memilih nama lain jika Anda mau, tetapi nama `env` adalah konvensi umum.

 

  1. Mengaktifkan Virtual Environment

   Setelah virtual environment dibuat, Anda perlu mengaktifkannya. Mengaktifkan virtual environment akan mengubah lingkungan kerja Anda sehingga semua paket yang diinstal dengan pip akan diinstal ke dalam virtual environment ini, bukan ke sistem Python global.

  •    Untuk Windows:

     

```bash
     env\Scripts\activate
     ```

 

  •    Untuk macOS/Linux:

     

```bash
     source env/bin/activate
     ```

 

   Setelah mengaktifkan virtual environment, prompt Anda akan menunjukkan nama environment aktif, seperti `(env)`, menunjukkan bahwa Anda berada dalam lingkungan terisolasi ini.

 

  1. Menonaktifkan Virtual Environment

   Jika Anda ingin keluar dari virtual environment, ketikkan perintah berikut:

  

 ```bash
   deactivate
   ```

 

   Menonaktifkan virtual environment akan mengembalikan Anda ke sistem Python global Anda.

 

2.3. Alat dan Pustaka Tambahan

Selain Django, ada beberapa pustaka tambahan yang akan sangat berguna dalam pembangunan aplikasi keuangan pribadi. Pustaka-pustaka ini termasuk Django REST framework untuk membuat API serta pustaka untuk mengelola basis data seperti PostgreSQL.

Pustaka Tambahan seperti Django REST Framework dan Basis Data

  1. Django REST Framework

   Django REST Framework (DRF) adalah pustaka yang sangat populer untuk membuat API web yang canggih dan fleksibel. Dengan DRF, Anda dapat dengan mudah membuat endpoint API untuk operasi CRUD (Create, Read, Update, Delete) yang diperlukan untuk aplikasi Anda.

   Untuk menginstal Django REST Framework, ketikkan perintah berikut di terminal atau command prompt:

   

```bash
   pip install djangorestframework
   ```

 

   Setelah instalasi selesai, Anda perlu menambahkan `rest_framework` ke dalam daftar `INSTALLED_APPS` di file `settings.py` proyek Django Anda. Ini akan memberi tahu Django untuk menggunakan DRF dalam proyek Anda:

  

 ```python
   INSTALLED_APPS = [
       ...
       'rest_framework',
      ...
   ]
   ```

 

  1. Basis Data (SQLite/PostgreSQL)

   Django mendukung berbagai sistem basis data, dan secara default, Django menggunakan SQLite, yang merupakan sistem basis data ringan dan file-based. SQLite sudah terintegrasi dalam Django, jadi jika Anda tidak memerlukan sistem basis data yang lebih kompleks, Anda dapat langsung menggunakan SQLite tanpa konfigurasi tambahan.

   Namun, jika Anda memerlukan fitur lebih canggih, seperti skalabilitas yang lebih baik atau kemampuan untuk menangani jumlah data yang lebih besar, Anda mungkin ingin menggunakan PostgreSQL, yang merupakan sistem basis data relasional yang lebih robust.

 

  •    Instalasi PostgreSQL:

     Untuk menggunakan PostgreSQL dengan Django, Anda perlu menginstal pustaka `psycopg2-binary`, yang merupakan adapter PostgreSQL untuk Python. Instal pustaka ini dengan perintah:

     

```bash
     pip install psycopg2-binary
     ```

 

  •    Konfigurasi PostgreSQL di Django:

     Setelah menginstal `psycopg2-binary`, Anda harus mengonfigurasi pengaturan basis data dalam file `settings.py` proyek Django Anda untuk menggunakan PostgreSQL sebagai basis data. Berikut adalah contoh konfigurasi untuk PostgreSQL:

     

```python
     DATABASES = {
         'default': {
             'ENGINE': 'django.db.backends.postgresql',
             'NAME': 'nama_database',
             'USER': 'nama_pengguna',
             'PASSWORD': 'kata_sandi',
             'HOST': 'localhost',
             'PORT': '5432',
         }
     }
     ```

Baca Juga

 

Membuat Proyek Django Baru

Setelah Anda menyelesaikan persiapan awal dengan menginstal Python, Django, dan pustaka tambahan, langkah selanjutnya adalah membuat proyek Django baru. Proses ini melibatkan inisialisasi proyek, pengaturan struktur direktori, dan pemahaman tentang berbagai file dan folder yang ada di dalam proyek. Pada bagian ini, kita akan membahas cara membuat proyek Django baru dan menjelaskan struktur dasar proyek yang dihasilkan.

 

3.1. Inisialisasi Proyek Django

Membuat Proyek Django Baru

Inisialisasi proyek Django adalah langkah pertama untuk memulai pengembangan aplikasi Anda. Proses ini akan membuat kerangka kerja dasar untuk aplikasi Anda, termasuk struktur direktori yang diperlukan dan beberapa file konfigurasi awal.

 

  1. Buka Terminal atau Command Prompt

   Pastikan bahwa virtual environment Anda sudah aktif sebelum menjalankan perintah berikut. Jika belum, aktifkan virtual environment Anda dengan perintah:

 

  •    Untuk Windows:

     

```bash
     env\Scripts\activate
     ```

 

  •    Untuk macOS/Linux:

     

```bash
     source env/bin/activate
     ```

 

  1. Jalankan Perintah untuk Membuat Proyek

   Gunakan perintah `django-admin startproject` diikuti dengan nama proyek Anda. Nama ini akan menjadi nama folder proyek Anda dan juga nama modul Python untuk proyek. Dalam hal ini, kita akan menggunakan nama `personal_finance` untuk proyek kita:

 

 ```bash
   django-admin startproject personal_finance
   ```

 

   Perintah ini akan menghasilkan struktur direktori baru dengan nama `personal_finance` di dalam direktori kerja Anda.

 

  1. Navigasikan ke Direktori Proyek

   Setelah proyek dibuat, navigasikan ke folder proyek dengan perintah berikut:

  

```bash
   cd personal_finance
   ```

 

   Sekarang Anda berada di direktori utama proyek Django Anda, siap untuk memulai konfigurasi lebih lanjut dan pengembangan aplikasi.

 

3.2. Struktur Proyek

Setelah inisialisasi proyek, Anda akan melihat struktur direktori dasar yang dihasilkan oleh perintah `startproject`. Memahami struktur ini sangat penting untuk pengembangan aplikasi Django yang efektif. Berikut adalah penjelasan mendetail mengenai direktori dan file yang ada dalam struktur proyek Django Anda.

 

Penjelasan Struktur Direktori dan File dalam Proyek Django

  1. Direktori `personal_finance/`

   Ini adalah direktori utama proyek Django Anda, dengan nama yang sama dengan nama proyek Anda. Di dalam direktori ini, Anda akan menemukan beberapa file dan folder penting:

 

  •    `manage.py`

     `manage.py` adalah skrip utilitas yang memungkinkan Anda untuk berinteraksi dengan proyek Django Anda. Anda akan sering menggunakan skrip ini untuk menjalankan perintah seperti `runserver`, `makemigrations`, `migrate`, dan `createsuperuser`. Misalnya, untuk menjalankan server pengembangan, Anda dapat menggunakan perintah berikut:

     

```bash
     python manage.py runserver
     ```

 

  •    `personal_finance/`

     Ini adalah direktori yang berisi konfigurasi proyek Django Anda. Di dalamnya, Anda akan menemukan file dan subdirektori berikut:

  •      `__init__.py`

       File ini adalah file kosong yang memberi tahu Python bahwa direktori ini harus diperlakukan sebagai paket Python. Anda tidak perlu mengubah file ini.

  •      `settings.py`

       File ini berisi pengaturan konfigurasi untuk proyek Django Anda. Di sini Anda akan mengatur berbagai aspek proyek, seperti pengaturan basis data, aplikasi yang terinstal, dan pengaturan keamanan. Contoh konfigurasi di `settings.py`:

       

```python
       INSTALLED_APPS = [
           'django.contrib.admin',
           'django.contrib.auth',
           'django.contrib.contenttypes',
           'django.contrib.sessions',
           'django.contrib.messages',
           'django.contrib.staticfiles',
           'rest_framework',  # Tambahkan pustaka Django REST Framework
       ]
       ```

 

  •      `urls.py`

       File ini mendefinisikan pola URL untuk proyek Django Anda. Di sini Anda akan mengatur rute URL yang menghubungkan URL yang diminta oleh pengguna ke views yang sesuai. Contoh konfigurasi `urls.py`:

```python
       from django.contrib import admin
       from django.urls import path


       urlpatterns = [
           path('admin/', admin.site.urls),
       ]
       ```

 

  •       `wsgi.py` dan `asgi.py`
  •        `wsgi.py`: Ini adalah entry point untuk server WSGI yang menjalankan aplikasi Django Anda di server produksi.
  •        `asgi.py`: Ini adalah entry point untuk server ASGI, yang memungkinkan Anda untuk menggunakan fitur asinkron di Django, seperti WebSockets.

 

  1. File dan Direktori Lain

   Setelah Anda mulai mengembangkan aplikasi, Anda akan menambahkan lebih banyak file dan direktori ke dalam proyek Anda. Berikut adalah beberapa file dan direktori tambahan yang umum ditemukan dalam proyek Django yang lebih kompleks:

  •    `requirements.txt`

     Meskipun tidak dibuat secara otomatis oleh Django, `requirements.txt` adalah file yang umum digunakan untuk mendokumentasikan dependensi proyek Anda. Anda dapat membuat file ini dengan perintah:

   

 ```bash
     pip freeze > requirements.txt
     ```
  •    `static/` dan `templates/`
  •    `static/`: Direktori ini digunakan untuk menyimpan file statis seperti CSS, JavaScript, dan gambar.
  •    `templates/`: Direktori ini digunakan untuk menyimpan file template HTML untuk antarmuka pengguna aplikasi Anda.
  •    `apps/`

     Saat aplikasi Anda berkembang, Anda mungkin akan membuat beberapa aplikasi terpisah di dalam proyek Django Anda. Setiap aplikasi memiliki struktur direktori sendiri dan dapat diatur di dalam folder `apps/`.

 

Desain Model Aplikasi

Desain model adalah salah satu langkah paling penting dalam pengembangan aplikasi Django. Model berfungsi sebagai representasi dari struktur data aplikasi Anda, dan mereka memainkan peran kunci dalam bagaimana data disimpan, dikelola, dan diakses dalam aplikasi. Pada bagian ini, kita akan membahas konsep dasar model dalam Django, membuat model untuk aplikasi keuangan pribadi, dan menjalankan migrasi untuk mengatur basis data.

 

4.1. Penjelasan Model dalam Django

Konsep Model sebagai Representasi Struktur Data

Dalam Django, model adalah cara untuk mendefinisikan struktur data aplikasi Anda dengan menggunakan kelas Python. Model ini memetakan data yang ada di aplikasi Anda ke tabel-tabel di basis data, dengan setiap atribut kelas mewakili kolom di tabel tersebut. Dengan kata lain, model adalah blueprint untuk basis data Anda.

Secara umum, model dalam Django adalah subclass dari `django.db.models.Model` dan setiap atribut kelas adalah instansi dari berbagai field yang disediakan oleh Django. Misalnya, Anda dapat menggunakan `CharField` untuk kolom teks pendek, `IntegerField` untuk kolom angka, dan `ForeignKey` untuk hubungan antar tabel.

Model tidak hanya mendefinisikan struktur data, tetapi juga menyediakan berbagai fitur untuk manipulasi data seperti validasi data, query database, dan relasi antar data. Contoh sederhana dari model dapat terlihat pada kode berikut:

 

```python
from django.db import models


class ExampleModel(models.Model):
    name = models.CharField(max_length=100)
    age = models.IntegerField()
```

 

Di sini, `name` adalah kolom teks dengan panjang maksimal 100 karakter, dan `age` adalah kolom angka. Django secara otomatis akan membuat tabel dengan dua kolom ini di basis data ketika Anda menjalankan migrasi.

 

4.2. Membuat Model

Definisi Model untuk Pengguna, Akun, Kategori, dan Transaksi

Untuk aplikasi keuangan pribadi, kita perlu mendefinisikan beberapa model yang akan merepresentasikan berbagai entitas yang ada dalam aplikasi. Berikut adalah model-model yang akan kita buat beserta penjelasannya:

 

  1. Model Pengguna

  Model ini akan menyimpan informasi pengguna aplikasi, seperti nama pengguna dan email.

   

```python
   # models.py
   from django.db import models


   class User(models.Model):
       username = models.CharField(max_length=150, unique=True)
       email = models.EmailField(unique=True)
       # Menambahkan metode untuk representasi string yang lebih baik
       def __str__(self):
           return self.username
   ```

 

  • `username`: Menyimpan nama pengguna, dengan panjang maksimal 150 karakter dan harus unik.
  • `email`: Menyimpan alamat email pengguna, yang juga harus unik.

 

  1. Model Akun

  Model ini akan mengelola informasi tentang akun keuangan pengguna.

 

 ```python
   # models.py
   class Account(models.Model):
       user = models.ForeignKey(User, on_delete=models.CASCADE)
       name = models.CharField(max_length=100)
       balance = models.DecimalField(max_digits=10, decimal_places=2)
       def __str__(self):
           return f'{self.name} ({self.user.username})'
   ```

 

  •  `user`: Relasi ke model `User`, menunjukkan akun milik pengguna tertentu.
  •  `name`: Nama akun dengan panjang maksimal 100 karakter.
  •  `balance`: Saldo akun, menggunakan tipe data `DecimalField` untuk menyimpan nilai uang.

 

  1. Model Kategori

   Model ini akan menyimpan kategori untuk transaksi keuangan.

 

 ```python
   # models.py
   class Category(models.Model):
       name = models.CharField(max_length=100)
       def __str__(self):
           return self.name
   ```

 

  •  `name`: Nama kategori dengan panjang maksimal 100 karakter.

 

  1. Model Transaksi

   Model ini akan menyimpan detail transaksi keuangan yang dilakukan oleh pengguna.

 

 ```python
   # models.py
   class Transaction(models.Model):
       account = models.ForeignKey(Account, on_delete=models.CASCADE)
       category = models.ForeignKey(Category, on_delete=models.CASCADE)
       amount = models.DecimalField(max_digits=10, decimal_places=2)
       date = models.DateField()
       description = models.TextField()
       def __str__(self):
           return f'{self.date} - {self.category.name}: {self.amount}'
   ```

 

  •  `account`: Relasi ke model `Account`, menunjukkan akun yang digunakan untuk transaksi.
  •  `category`: Relasi ke model `Category`, menunjukkan kategori dari transaksi.
  •  `amount`: Jumlah uang yang terlibat dalam transaksi.
  •  `date`: Tanggal transaksi.
  •  `description`: Deskripsi transaksi, menggunakan tipe data `TextField` untuk teks yang lebih panjang.

 

4.3. Migrasi Model ke Database

Menjalankan Migrasi untuk Membuat Tabel di Basis Data

Setelah Anda mendefinisikan model-model ini, langkah berikutnya adalah melakukan migrasi. Migrasi adalah proses di mana perubahan pada model diubah menjadi struktur tabel yang sesuai di basis data. Ada dua langkah utama dalam proses migrasi:

 

  1. Membuat File Migrasi

   Jalankan perintah `makemigrations` untuk membuat file migrasi yang berisi instruksi untuk Django tentang bagaimana menerapkan perubahan model ke basis data:

  

 ```bash
   python manage.py makemigrations
   ```

  

Perintah ini akan memeriksa model Anda dan menghasilkan file migrasi yang berisi perubahan yang diperlukan untuk menyelaraskan model dengan basis data.

 

  1. menerapkan Migrasi ke Basis Data

   Jalankan perintah `migrate` untuk menerapkan perubahan yang tercantum dalam file migrasi ke basis data Anda:

 

 ```bash
   python manage.py migrate
   ```

 

   Perintah ini akan membuat tabel di basis data sesuai dengan definisi model yang telah Anda buat. Setelah migrasi berhasil, Anda akan melihat tabel-tabel yang baru dibuat dalam basis data Anda.

 

Membuat Views dan Templates

Setelah Anda selesai dengan desain model aplikasi, langkah berikutnya adalah membuat views dan templates. Views mengontrol logika aplikasi dan menghubungkan data dari model ke templates, sedangkan templates menentukan bagaimana data tersebut ditampilkan kepada pengguna. Dalam bagian ini, kita akan membahas peran views dan templates, membuat views untuk aplikasi keuangan pribadi, serta merancang template HTML untuk dashboard.

5.1. Penjelasan Views dan Templates

Fungsi Views dalam Logika Aplikasi

Di Django, views adalah komponen yang menangani logika aplikasi dan mengontrol bagaimana data ditampilkan kepada pengguna. View berfungsi sebagai jembatan antara model dan template:

  • Logika Bisnis: Views berisi kode yang menentukan apa yang terjadi ketika pengguna mengakses URL tertentu. Ini termasuk mengambil data dari model, memproses data tersebut, dan mengirim data ke template untuk ditampilkan.
  • Respons HTTP: Views menghasilkan objek `HttpResponse` yang dikirimkan kembali ke pengguna. Ini bisa berupa halaman HTML, JSON, atau bentuk data lainnya.

Contoh View Sederhana:

 

 ```python
  from django.shortcuts import render
  from .models import Transaction


  def dashboard(request):
      transactions = Transaction.objects.all()
      return render(request, 'dashboard.html', {'transactions': transactions})
  ```

 

Dalam contoh ini, view `dashboard` mengambil semua data transaksi dari model `Transaction` dan mengirimkan data tersebut ke template `dashboard.html` untuk ditampilkan.

 

Fungsi Templates untuk Tampilan Data

Templates di Django adalah file HTML yang digunakan untuk menentukan bagaimana data ditampilkan kepada pengguna. Templates menyediakan struktur halaman web dengan menggunakan template language Django untuk menyisipkan data dari views ke dalam HTML.

  • Template Syntax: Django Templates menggunakan sintaks seperti `{{ }}` untuk menampilkan data dan `{% %}` untuk kontrol alur, seperti loop atau kondisional.

Contoh Template Sederhana:

 

 ```html
  <!DOCTYPE html>
  <html>
  <head>
      <title>Dashboard</title>
  </head>
  <body>
      <h1>Keuangan Pribadi</h1>
      <table>
          <tr>
              <th>Tanggal</th>
              <th>Kategori</th>
              <th>Deskripsi</th>
              <th>Jumlah</th>
          </tr>
          {% for transaction in transactions %}
          <tr>
              <td>{{ transaction.date }}</td>
              <td>{{ transaction.category.name }}</td>
              <td>{{ transaction.description }}</td>
              <td>{{ transaction.amount }}</td>
          </tr>
          {% endfor %}
      </table>
  </body>
  </html>
  ```

 

    Dalam template ini, data transaksi yang diterima dari view `dashboard` ditampilkan dalam bentuk tabel.

 

5.2. Membuat Views

Membuat Views untuk Menampilkan Data Keuangan

Sekarang, mari kita buat beberapa views untuk menampilkan data keuangan dan memungkinkan interaksi pengguna dengan aplikasi. Kita akan membuat dua views utama: satu untuk menampilkan data di dashboard dan satu lagi untuk menambahkan transaksi baru.

 

  1. View Dashboard

   View ini akan mengambil data transaksi dari model `Transaction` dan menampilkannya di dashboard:

 

 ```python
   # views.py
   from django.shortcuts import render
   from .models import Transaction


   def dashboard(request):
       transactions = Transaction.objects.all()
       return render(request, 'dashboard.html', {'transactions': transactions})
   ```

 

   Di sini, `dashboard` mengambil semua objek `Transaction` dan mengirimkan objek tersebut ke template `dashboard.html`.

 

  1. View untuk Menambahkan Transaksi

   View ini akan menangani formulir untuk menambah transaksi baru:

 

 ```python
   # views.py
   from django.shortcuts import render, redirect
   from .forms import TransactionForm


   def add_transaction(request):
       if request.method == 'POST':
           form = TransactionForm(request.POST)
           if form.is_valid():
               form.save()
               return redirect('dashboard')
       else:
           form = TransactionForm()
       return render(request, 'add_transaction.html', {'form': form})
   ```

 

   Di sini, `add_transaction` memproses data formulir dari pengguna. Jika data valid, transaksi baru disimpan di basis data dan pengguna diarahkan kembali ke dashboard.

 

5.3. Merancang Template HTML

Membuat Template HTML untuk Dashboard

Setelah views siap, Anda perlu membuat template HTML yang akan menampilkan data keuangan kepada pengguna. Template ini harus dirancang dengan baik agar informasi disajikan dengan jelas dan mudah dibaca.

 

  1. Template untuk Dashboard

   Template ini akan menampilkan daftar transaksi dalam bentuk tabel:

 

 ```html
   <!-- templates/dashboard.html -->
   <!DOCTYPE html>
   <html>
   <head>
       <title>Dashboard</title>
   </head>
   <body>
       <h1>Keuangan Pribadi</h1>
       <table>
           <thead>
               <tr>
                   <th>Tanggal</th>
                   <th>Kategori</th>
                   <th>Deskripsi</th>
                   <th>Jumlah</th>
               </tr>
           </thead>
           <tbody>
               {% for transaction in transactions %}
               <tr>
                   <td>{{ transaction.date }}</td>
                   <td>{{ transaction.category.name }}</td>
                   <td>{{ transaction.description }}</td>
                   <td>{{ transaction.amount }}</td>
               </tr>
               {% endfor %}
           </tbody>
       </table>
       <a href="{% url 'add_transaction' %}">Tambah Transaksi</a>
   </body>
   </html>
   ```

 

   Di sini, template `dashboard.html` menampilkan data transaksi dalam format tabel dan menyediakan tautan ke halaman untuk menambahkan transaksi baru.

 

  1. Template untuk Menambahkan Transaksi

   Template ini akan berisi formulir untuk memasukkan data transaksi baru:

 

 ```html
   <!-- templates/add_transaction.html -->
   <!DOCTYPE html>
   <html>
   <head>
       <title>Tambah Transaksi</title>
   </head>
   <body>
       <h1>Tambah Transaksi Baru</h1>
       <form method="post">
           {% csrf_token %}
           {{ form.as_p }}
           <button type="submit">Simpan</button>
       </form>
       <a href="{% url 'dashboard' %}">Kembali ke Dashboard</a>
   </body>
   </html>
   ```

  

   Template `add_transaction.html` menampilkan formulir `TransactionForm` yang memungkinkan pengguna untuk memasukkan data transaksi baru.

 

Membuat Forms dan Validasi Input

Forms dalam Django adalah alat yang kuat untuk menangani input dari pengguna dan memanipulasi data yang dikirimkan melalui formulir web. Dengan forms, Anda dapat membuat formulir HTML, mengelola data yang dikirimkan, dan melakukan validasi untuk memastikan data tersebut sesuai dengan kriteria yang diinginkan. Pada bagian ini, kita akan menjelaskan penggunaan forms dalam Django, membuat forms untuk menambah dan mengedit transaksi, serta membahas bagaimana melakukan validasi input dan menangani error.

 

6.1. Penjelasan Forms dalam Django

Penggunaan Forms untuk Menangani Input Pengguna

Forms di Django adalah kelas Python yang menangani data yang dikirimkan dari formulir HTML oleh pengguna. Forms memudahkan proses pembuatan formulir, pemrosesan data, dan validasi input. Forms di Django menyediakan cara yang bersih dan terstruktur untuk mengelola input pengguna dan menyimpan data ke dalam basis data.

 

Beberapa fitur utama dari Django forms meliputi:

  • Penggantian HTML Form: Forms menyediakan cara untuk mendefinisikan elemen formulir HTML seperti input teks, dropdown, dan checkbox, menggunakan kelas Python. Ini mengurangi kebutuhan untuk menulis HTML formulir secara manual.
  • Validasi Data: Forms menyediakan mekanisme untuk memvalidasi data yang dikirimkan pengguna, seperti memastikan bahwa data tidak kosong, format data benar, atau data memenuhi kriteria tertentu.
  • Penanganan Error: Forms memiliki built-in error handling yang memudahkan Anda untuk menampilkan pesan kesalahan kepada pengguna jika input tidak valid.

Contoh Formulir Sederhana:

 

 ```python
  from django import forms
  from .models import Transaction


  class TransactionForm(forms.ModelForm):
      class Meta:
          model = Transaction
          fields = ['account', 'category', 'amount', 'date', 'description']
  ```

 

  Dalam contoh ini, `TransactionForm` adalah formulir yang berdasarkan model `Transaction`. Kelas ini akan menghasilkan formulir HTML untuk input data transaksi, serta melakukan validasi untuk memastikan semua field diisi dengan benar.

 

6.2. Membuat Forms

Membuat Form untuk Menambah dan Mengedit Transaksi

Untuk aplikasi keuangan pribadi, Anda akan membutuhkan formulir untuk dua tujuan utama: menambahkan transaksi baru dan mengedit transaksi yang ada. Berikut adalah cara untuk membuat kedua formulir tersebut.

 

  1. Formulir untuk Menambah Transaksi Baru

   Formulir ini memungkinkan pengguna untuk memasukkan data transaksi baru ke dalam aplikasi:

 

 ```python
   # forms.py
   from django import forms
   from .models import Transaction


   class TransactionForm(forms.ModelForm):
       class Meta:
           model = Transaction
           fields = ['account', 'category', 'amount', 'date', 'description']
   ```

 

  •  `account`: Field untuk memilih akun dari dropdown yang tersedia.
  •  `category`: Field untuk memilih kategori dari dropdown yang tersedia.
  •   `amount`: Field untuk memasukkan jumlah uang untuk transaksi.
  •   `date`: Field untuk memilih tanggal transaksi.
  •   `description`: Field untuk memasukkan deskripsi transaksi.

 

   Anda dapat menggunakan formulir ini di view untuk menangani penginputan data dari pengguna dan menyimpannya ke basis data.

 

  1. Formulir untuk Mengedit Transaksi yang Ada

   Untuk mengedit transaksi yang sudah ada, Anda dapat menggunakan `TransactionForm` yang sama dengan sedikit modifikasi dalam view:

  

 ```python
   # views.py
   from django.shortcuts import get_object_or_404, redirect
   from .forms import TransactionForm
   from .models import Transaction


   def edit_transaction(request, pk):
       transaction = get_object_or_404(Transaction, pk=pk)
       if request.method == 'POST':
           form = TransactionForm(request.POST, instance=transaction)
           if form.is_valid():
               form.save()
               return redirect('dashboard')
       else:
           form = TransactionForm(instance=transaction)
       return render(request, 'edit_transaction.html', {'form': form})
   ```

 

 `instance=transaction`: Menyediakan instance dari transaksi yang ada untuk diubah.

 

6.3. Validasi Input dan Penanganan Error

Validasi Input dan Penanganan Error dalam Form

Forms di Django tidak hanya untuk menyusun formulir HTML tetapi juga untuk melakukan validasi input pengguna dan menangani error. Berikut adalah beberapa cara untuk melakukan validasi input dan penanganan error dalam formulir Anda:

 

  1. Menambahkan Validasi Khusus

   Anda bisa menambahkan metode `clean` pada form untuk melakukan validasi data yang lebih kompleks:

 

 ```python
   # forms.py
   class TransactionForm(forms.ModelForm):
       class Meta:
           model = Transaction
           fields = ['account', 'category', 'amount', 'date', 'description']


       def clean_amount(self):
           amount = self.cleaned_data.get('amount')
           if amount <= 0:
               raise forms.ValidationError("Jumlah harus lebih besar dari nol.")
           return amount
   ```

 

   Di sini, `clean_amount` memastikan bahwa jumlah transaksi harus lebih besar dari nol. Jika tidak, metode ini akan menghasilkan pesan kesalahan.

 

  1. Menangani Error pada Form

   Jika formulir tidak valid, Django akan menampilkan pesan kesalahan yang dapat Anda tampilkan di template:

  

 ```html
   <!-- templates/add_transaction.html -->
   <!DOCTYPE html>
   <html>
   <head>
       <title>Tambah Transaksi</title>
   </head>
   <body>
       <h1>Tambah Transaksi Baru</h1>
       <form method="post">
           {% csrf_token %}
           {{ form.as_p }}
           {% if form.errors %}
               <ul>
                   {% for field in form %}
                       {% for error in field.errors %}
                           <li>{{ field.label }}: {{ error }}</li>
                       {% endfor %}
                   {% endfor %}
                   {% for error in form.non_field_errors %}
                       <li>{{ error }}</li>
                   {% endfor %}
               </ul>
           {% endif %}
           <button type="submit">Simpan</button>
       </form>
       <a href="{% url 'dashboard' %}">Kembali ke Dashboard</a>
   </body>
   </html>
   ```

 

   Di sini, error dari setiap field dan error non-field ditampilkan di template jika ada masalah dengan data yang dikirimkan.

 

  1. Validasi dan Penanganan Error di View

   Anda juga dapat menangani error dalam view dengan memeriksa validitas form:

   

```python
   # views.py
   def add_transaction(request):
       if request.method == 'POST':
           form = TransactionForm(request.POST)
           if form.is_valid():
               form.save()
               return redirect('dashboard')
           else:
               # Form tidak valid, data akan dikembalikan ke template
               return render(request, 'add_transaction.html', {'form': form})
       else:
           form = TransactionForm()
       return render(request, 'add_transaction.html', {'form': form})
   ```

 

   Dalam kasus ini, jika formulir tidak valid, data formulir yang telah dimasukkan akan dikembalikan ke template bersama dengan pesan error.

 

Mengimplementasikan Fitur Autentikasi dan Otorisasi

Fitur autentikasi dan otorisasi adalah elemen penting dalam aplikasi web untuk memastikan keamanan dan akses yang tepat ke berbagai bagian aplikasi. Django menyediakan sistem autentikasi bawaan yang lengkap dan mudah digunakan, yang mencakup fungsionalitas seperti login, logout, dan pendaftaran pengguna. Dalam bagian ini, kita akan membahas bagaimana sistem autentikasi Django bekerja, dan langkah-langkah untuk membuat fitur login, logout, dan pendaftaran pengguna dalam aplikasi keuangan pribadi Anda.

 

7.1. Penjelasan Sistem Autentikasi Bawaan Django

Fitur Login, Logout, dan Pendaftaran Pengguna dalam Django

Django menyediakan sistem autentikasi bawaan yang memungkinkan Anda untuk menangani proses login, logout, dan pendaftaran pengguna tanpa harus membuat solusi dari awal. Sistem ini mencakup beberapa fitur kunci yang memudahkan Anda dalam mengelola pengguna dan kontrol akses:

 

  1. Login:
  • Fungsi: Mengizinkan pengguna untuk mengakses akun mereka dengan memasukkan nama pengguna dan kata sandi yang benar.
  • URL dan View: Django menyediakan view `LoginView` yang secara otomatis menangani proses login.

 

  1. Logout:
  • Fungsi: Mengakhiri sesi pengguna dan mengeluarkan mereka dari aplikasi.
  • URL dan View: Django menyediakan view `LogoutView` untuk menangani proses logout.

 

  1. Pendaftaran Pengguna:
  • Fungsi: Memungkinkan pengguna baru untuk membuat akun dengan menyediakan nama pengguna, email, dan kata sandi.
  • URL dan View: Anda dapat menggunakan `UserCreationForm` untuk menangani pendaftaran pengguna baru.

 

  1. Manajemen Pengguna:
  • Fungsi: Mengelola data pengguna dan sesi mereka. Sistem ini juga mendukung fitur seperti pengaturan ulang kata sandi dan pembaruan profil pengguna.

 

Implementasi Fitur

Login:

  • View: `LoginView` menyediakan form login dan menangani otentikasi pengguna.
  • Template: Template untuk formulir login.

 

Logout:

  • View: `LogoutView` yang menangani proses logout pengguna.
  • Template: Anda tidak perlu template khusus untuk logout; pengguna akan diarahkan ke halaman home atau ke halaman yang Anda tentukan setelah logout.

 

Pendaftaran Pengguna:

  • View: Kustom view untuk mengelola pendaftaran pengguna.
  • Template: Template untuk formulir pendaftaran pengguna.

 

7.2. Membuat Sistem Login, Logout, dan Pendaftaran Pengguna

Membuat Views dan Templates untuk Sistem Autentikasi

Sekarang, kita akan membuat views dan templates yang diperlukan untuk login, logout, dan pendaftaran pengguna. Kami akan menggunakan views bawaan dari Django untuk login dan logout, dan membuat view kustom untuk pendaftaran pengguna.

 

  1. Membuat View untuk Pendaftaran Pengguna

   Kita akan menggunakan `UserCreationForm` untuk membuat formulir pendaftaran pengguna. Berikut adalah view untuk menangani pendaftaran pengguna baru:

  

 ```python
   # views.py
   from django.contrib.auth import login, authenticate
   from django.contrib.auth.forms import UserCreationForm
   from django.shortcuts import render, redirect


   def register(request):
       if request.method == 'POST':
           form = UserCreationForm(request.POST)
           if form.is_valid():
               user = form.save()
               username = form.cleaned_data.get('username')
               raw_password = form.cleaned_data.get('password1')
               user = authenticate(username=username, password=raw_password)
               login(request, user)
               return redirect('dashboard')
       else:
           form = UserCreationForm()
       return render(request, 'register.html', {'form': form})
   ```

 

  Penjelasan: View `register` menangani data dari form pendaftaran. Jika data form valid, pengguna baru dibuat, diautentikasi, dan langsung login. Pengguna kemudian dialihkan ke halaman dashboard.

 

  1. Template untuk Pendaftaran Pengguna

   Berikut adalah template HTML untuk formulir pendaftaran pengguna baru:

  

 ```html
   <!-- templates/register.html -->
   <!DOCTYPE html>
   <html>
   <head>
       <title>Daftar</title>
   </head>
   <body>
       <h1>Daftar Akun Baru</h1>
       <form method="post">
           {% csrf_token %}
           {{ form.as_p }}
           <button type="submit">Daftar</button>
       </form>
       <a href="{% url 'login' %}">Sudah punya akun? Masuk di sini</a>
   </body>
   </html>
   ```

 

   Penjelasan: Template ini menampilkan formulir pendaftaran pengguna dan menyediakan tautan ke halaman login.

 

  1. Membuat View untuk Login dan Logout Pengguna

   Anda dapat menggunakan `LoginView` dan `LogoutView` bawaan dari Django dengan konfigurasi default:

  

 ```python
   # urls.py
   from django.urls import path
   from django.contrib.auth import views as auth_views
   from . import views


   urlpatterns = [
       path('login/', auth_views.LoginView.as_view(template_name='login.html'), name='login'),
       path('logout/', auth_views.LogoutView.as_view(), name='logout'),
       path('register/', views.register, name='register'),
       path('', views.dashboard, name='dashboard'),
       # ... other url patterns
   ]
   ```

 

   Penjelasan:

  •  `auth_views.LoginView`: Menangani proses login dengan template `login.html`.
  • `auth_views.LogoutView`: Menangani proses logout dan mengarahkan ke halaman home secara default.

 

  1. Template untuk Login Pengguna

   Berikut adalah template HTML untuk formulir login:

  

 ```html
   <!-- templates/login.html -->
   <!DOCTYPE html>
   <html>
   <head>
       <title>Masuk</title>
   </head>
   <body>
       <h1>Masuk ke Akun Anda</h1>
       <form method="post">
           {% csrf_token %}
           {{ form.as_p }}
           <button type="submit">Masuk</button>
       </form>
       <a href="{% url 'register' %}">Belum punya akun? Daftar di sini</a>
   </body>
   </html>
   ```

 

  • Penjelasan: Template ini menampilkan formulir login pengguna dengan tautan untuk pendaftaran bagi pengguna baru.

 

  1. Template untuk Logout Pengguna

   Anda tidak memerlukan template khusus untuk logout karena Django akan mengarahkan pengguna kembali ke halaman utama atau halaman yang Anda tentukan setelah logout. Anda bisa mengkonfigurasi halaman yang diinginkan dengan menambahkan `next_page` dalam `LogoutView`:

 

 ```python
   # urls.py
   path('logout/', auth_views.LogoutView.as_view(next_page='login'), name='logout'),
   ```

 

  • Penjelasan: Setelah logout, pengguna akan diarahkan kembali ke halaman login.

 

API dan Integrasi dengan Frontend

Di era digital saat ini, banyak aplikasi web membutuhkan kemampuan untuk berinteraksi dengan berbagai sistem melalui API (Application Programming Interface). Dalam konteks aplikasi keuangan pribadi, API memungkinkan Anda untuk membuat layanan yang dapat diakses oleh aplikasi lain atau frontend berbasis JavaScript. Django REST Framework (DRF) adalah alat yang sangat efektif untuk membangun API yang dapat digunakan untuk menghubungkan frontend dengan backend aplikasi Django Anda. Dalam bagian ini, kita akan membahas Django REST Framework, kelebihannya, dan bagaimana Anda dapat menggunakannya untuk membuat API endpoints yang diperlukan untuk aplikasi keuangan pribadi Anda.

 

8.1. Penjelasan Django REST Framework

Kelebihan Django REST Framework untuk Pembuatan API

Django REST Framework (DRF) adalah pustaka fleksibel dan powerful untuk membangun API web di Django. DRF menyederhanakan proses pembuatan, pengelolaan, dan dokumentasi API dengan beberapa fitur unggulan:

 

  1. Kelebihan DRF:
  •  Fitur CRUD yang Terintegrasi:

     DRF menyediakan viewsets dan serializers yang memungkinkan Anda untuk dengan mudah membuat operasi CRUD (Create, Read, Update, Delete) untuk model Django Anda. Ini mempercepat pengembangan API dengan menyediakan kelas dasar yang bisa Anda extend untuk kebutuhan spesifik Anda.

  • Serialisasi Data:

     DRF memiliki mekanisme serialisasi data yang kuat. Dengan serializers, Anda dapat mengonversi data model Django menjadi format JSON yang dapat dipahami oleh frontend dan aplikasi lain, serta sebaliknya.

  • Autentikasi dan Otorisasi:

     DRF menyediakan berbagai metode autentikasi dan otorisasi, seperti token-based authentication, OAuth, dan session authentication. Ini mempermudah penerapan kontrol akses dan keamanan API Anda.

  • Dukungan Dokumentasi API:

     DRF mendukung berbagai solusi dokumentasi API seperti Swagger dan ReDoc. Dengan fitur ini, Anda dapat menghasilkan dokumentasi API yang interaktif dan mudah dipahami oleh pengembang lain.

  • Fitur Pagination:

     DRF menyediakan built-in pagination untuk mengelola hasil query yang besar. Ini memungkinkan Anda untuk membagi data menjadi beberapa halaman, sehingga mengoptimalkan kinerja dan pengalaman pengguna.

  • Dukungan untuk Filtering dan Searching:

     DRF memungkinkan Anda untuk dengan mudah menambahkan filter dan pencarian ke endpoint API Anda. Ini membantu pengguna dalam menemukan data yang relevan dalam koleksi data yang besar.

  • ViewSets dan Routers:

     DRF menggunakan viewsets dan routers untuk menangani rute API. Ini membuat kode lebih bersih dan lebih mudah dikelola, serta mengurangi jumlah konfigurasi yang diperlukan untuk menambahkan endpoint baru.

 

Instalasi Django REST Framework

Untuk memulai dengan DRF, Anda perlu menginstalnya terlebih dahulu. Berikut adalah cara untuk menambahkan DRF ke proyek Django Anda:

 

```bash
pip install djangorestframework
```

 

Setelah menginstal DRF, tambahkan `rest_framework` ke dalam daftar `INSTALLED_APPS` di file `settings.py` Anda:

 

```python
# settings.py
INSTALLED_APPS = [
    # Aplikasi Django lainnya
    'rest_framework',
    # Aplikasi Anda
]
```

 

8.2. Membuat API Endpoints

Sekarang kita akan membuat API endpoints untuk aplikasi keuangan pribadi Anda. Langkah ini melibatkan pembuatan serializer, views, dan konfigurasi URL untuk menghubungkan frontend dengan backend.

 

  1. Menyiapkan Serializer

Serializer di DRF digunakan untuk mengonversi data model Django menjadi format JSON. Berikut adalah contoh serializer untuk model `Transaction`:

 

```python
# serializers.py
from rest_framework import serializers
from .models import Transaction


class TransactionSerializer(serializers.ModelSerializer):
    class Meta:
        model = Transaction
        fields = '__all__'
```

 

Penjelasan:

  • `TransactionSerializer` adalah subclass dari `serializers.ModelSerializer`.
  • `Meta` kelas di dalam serializer mendefinisikan model yang diserialisasi dan field yang disertakan dalam representasi JSON.

 

  1. Membuat ViewSets

ViewSets di DRF adalah cara untuk menentukan logika API yang dapat menangani berbagai operasi CRUD. Berikut adalah contoh `TransactionViewSet`:

 

```python
# views.py
from rest_framework import viewsets
from .models import Transaction
from .serializers import TransactionSerializer


class TransactionViewSet(viewsets.ModelViewSet):
    queryset = Transaction.objects.all()
    serializer_class = TransactionSerializer
```

 

Penjelasan:

  • `TransactionViewSet` adalah subclass dari `viewsets.ModelViewSet`.
  • `queryset` menentukan data yang akan diambil dari database.
  • `serializer_class` menghubungkan viewset dengan serializer yang mengubah data menjadi format JSON.

 

  1. Mengkonfigurasi URL Endpoints

Anda perlu menghubungkan viewset dengan URL endpoints. Ini dilakukan dengan menambahkan rute untuk API di `urls.py` Anda:

 

```python
# urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import TransactionViewSet


router = DefaultRouter()
router.register(r'transactions', TransactionViewSet)


urlpatterns = [
    path('api/', include(router.urls)),
    # URL lainnya
]
```

 

Penjelasan:

  • `DefaultRouter` secara otomatis menghasilkan rute untuk operasi CRUD (`list`, `create`, `retrieve`, `update`, dan `destroy`) untuk `TransactionViewSet`.
  • `router.register()` mendaftarkan `TransactionViewSet` di bawah rute `api/transactions`.

 

  1. Testing API Endpoints

Setelah mengonfigurasi API, penting untuk memastikan bahwa endpoint Anda berfungsi seperti yang diharapkan. Anda bisa menggunakan alat seperti Postman atau curl untuk menguji berbagai metode HTTP (GET, POST, PUT, DELETE) pada endpoint API Anda. Berikut adalah contoh perintah curl untuk menguji endpoint:

 

  • GET (Ambil daftar transaksi):

 

```bash
  curl -X GET http://localhost:8000/api/transactions/
  ```

 

  • POST (Tambahkan transaksi baru):

 

 ```bash
  curl -X POST http://localhost:8000/api/transactions/ -H "Content-Type: application/json" -d '{"account":1,"category":1,"amount":100.00,"date":"2024-01-01","description":"New transaction"}'
  ```

 

  • PUT (Update transaksi yang ada):

  

```bash
  curl -X PUT http://localhost:8000/api/transactions/1/ -H "Content-Type: application/json" -d '{"account":1,"category":1,"amount":150.00,"date":"2024-01-01","description":"Updated transaction"}'
  ```

 

  • DELETE (Hapus transaksi):

  

```bash
  curl -X DELETE http://localhost:8000/api/transactions/1/
  ```

 

Penjelasan:

  • GET: Mengambil daftar semua transaksi.
  • POST: Menambahkan transaksi baru.
  • PUT: Memperbarui transaksi yang ada.
  • DELETE: Menghapus transaksi berdasarkan ID.

 

  1. Integrasi dengan Frontend

Jika Anda menggunakan frontend berbasis JavaScript seperti React atau Vue.js, Anda dapat memanggil API ini untuk mengambil dan mengirim data. Berikut adalah contoh fetch API dengan JavaScript untuk mendapatkan data transaksi:

 

```javascript
fetch('http://localhost:8000/api/transactions/')
    .then(response => response.json())
    .then(data => {
        console.log(data);  // Menampilkan data transaksi di konsol
    });
```

Testing dan Debugging

Dalam pengembangan perangkat lunak, testing dan debugging adalah dua langkah penting untuk memastikan bahwa aplikasi Anda tidak hanya berfungsi dengan baik, tetapi juga bebas dari bug yang dapat mempengaruhi pengalaman pengguna. Testing membantu Anda memastikan bahwa semua bagian aplikasi Anda berfungsi seperti yang diharapkan, sedangkan debugging membantu Anda menemukan dan memperbaiki masalah saat mereka muncul. Dalam bagian ini, kita akan membahas mengapa testing itu penting, serta bagaimana cara menulis unit tests untuk model, views, dan forms dalam aplikasi Django Anda.

 

9.1. Penjelasan Pentingnya Testing

Testing adalah proses sistematis untuk mengevaluasi perangkat lunak dengan tujuan menemukan bug, memastikan bahwa aplikasi berfungsi sesuai spesifikasi, dan meningkatkan kualitas perangkat lunak. Ada beberapa alasan mengapa testing sangat penting dalam pengembangan aplikasi:

  1. Menjamin Kualitas Aplikasi

Testing memastikan bahwa setiap fitur aplikasi bekerja sesuai harapan. Tanpa testing yang memadai, ada risiko bahwa fitur-fitur baru atau perubahan yang dibuat bisa menyebabkan kerusakan pada bagian lain dari aplikasi yang sudah ada. Dengan testing, Anda bisa memastikan bahwa setiap perubahan atau penambahan fitur tidak merusak fungsionalitas yang ada.

 

  1. Mencegah Bug di Produksi

Dengan melakukan testing yang komprehensif, Anda dapat menemukan dan memperbaiki bug sebelum aplikasi diluncurkan ke lingkungan produksi. Ini mengurangi kemungkinan bahwa pengguna akhir akan mengalami masalah yang bisa merusak reputasi aplikasi Anda.

 

  1. Memudahkan Refactoring Kode

Testing memudahkan Anda untuk merubah dan memperbarui kode dengan cara yang aman. Dengan adanya tes yang ada, Anda dapat melakukan perubahan pada kode tanpa takut merusak bagian lain dari aplikasi karena Anda dapat menjalankan tes untuk memastikan semuanya masih berfungsi dengan baik.

 

  1. Meningkatkan Kepercayaan Diri dalam Pengembangan

Testing memberikan umpan balik yang cepat dan jelas tentang apakah aplikasi Anda berfungsi dengan benar atau tidak. Ini membantu pengembang untuk lebih percaya diri dalam pengembangan dan pengiriman aplikasi, serta mengurangi kecemasan tentang potensi masalah yang mungkin ada.

 

  1. Meningkatkan Dokumentasi Kode

Unit tests sering kali berfungsi sebagai dokumentasi tambahan untuk bagaimana aplikasi Anda harus berfungsi. Dengan melihat tes, pengembang lain dapat memahami bagaimana berbagai bagian aplikasi seharusnya bekerja.

 

  1. Mengurangi Biaya Pemeliharaan

Menemukan dan memperbaiki bug lebih awal dalam siklus pengembangan lebih murah dibandingkan dengan memperbaikinya setelah aplikasi sudah diluncurkan. Testing yang baik mengurangi biaya pemeliharaan di masa depan dengan mencegah masalah yang bisa menjadi lebih besar seiring waktu.

 

9.2. Menulis Unit Tests

Unit testing di Django adalah proses penulisan tes otomatis untuk memeriksa unit terkecil dari fungsionalitas aplikasi, seperti model, views, dan forms. Django menyediakan framework testing bawaan yang memungkinkan Anda untuk menulis dan menjalankan tes dengan mudah.

 

  1. Menulis Unit Tests untuk Model

Unit tests untuk model biasanya memeriksa apakah model Anda menyimpan data dengan benar, apakah relasi antar model berfungsi dengan baik, dan apakah logika model Anda bekerja seperti yang diharapkan. Berikut adalah contoh tes untuk model `Transaction`:

 

```python
# tests.py
from django.test import TestCase
from .models import Transaction, User, Account, Category


class TransactionModelTest(TestCase):


    def setUp(self):
        # Setup data untuk tes
        user = User.objects.create(username='testuser', email='[email protected]')
        account = Account.objects.create(user=user, name='Test Account', balance=1000.00)
        category = Category.objects.create(name='Test Category')
        Transaction.objects.create(account=account, category=category, amount=100.00, date='2024-01-01', description='Test Transaction')


    def test_transaction_creation(self):
        transaction = Transaction.objects.get(description='Test Transaction')
        self.assertEqual(transaction.amount, 100.00)
        self.assertEqual(transaction.description, 'Test Transaction')
        self.assertIsNotNone(transaction.date)
```

 

Penjelasan:

  • `setUp` method menyiapkan data yang diperlukan untuk tes.
  • `test_transaction_creation` method memeriksa apakah transaksi yang dibuat memiliki nilai yang benar dan apakah data disimpan dengan benar.

 

  1. Menulis Unit Tests untuk Views

Unit tests untuk views biasanya memeriksa apakah views mengembalikan respons yang diharapkan dan apakah data yang dikirim ke template sudah benar. Berikut adalah contoh tes untuk view `dashboard`:

 

```python
# tests.py (lanjutan)
from django.urls import reverse


class DashboardViewTest(TestCase):


    def setUp(self):
        # Setup data untuk tes
        user = User.objects.create(username='testuser', email='[email protected]')
        account = Account.objects.create(user=user, name='Test Account', balance=1000.00)
        category = Category.objects.create(name='Test Category')
        Transaction.objects.create(account=account, category=category, amount=100.00, date='2024-01-01', description='Test Transaction')


    def test_dashboard_view_status_code(self):
        url = reverse('dashboard')
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)


    def test_dashboard_view_contains_correct_html(self):
        url = reverse('dashboard')
        response = self.client.get(url)
        self.assertContains(response, 'Keuangan Pribadi')
        self.assertContains(response, 'Test Transaction')
```

 

Penjelasan:

  • `test_dashboard_view_status_code` memeriksa apakah view `dashboard` mengembalikan status HTTP 200 (OK).
  • `test_dashboard_view_contains_correct_html` memeriksa apakah HTML yang dihasilkan mengandung teks yang diharapkan.

 

  1. Menulis Unit Tests untuk Forms

Unit tests untuk forms biasanya memeriksa apakah form melakukan validasi input dengan benar dan apakah data yang valid disimpan dengan baik. Berikut adalah contoh tes untuk form `TransactionForm`:

 

```python
# tests.py (lanjutan)
from .forms import TransactionForm


class TransactionFormTest(TestCase):


    def test_form_valid_data(self):
        user = User.objects.create(username='testuser', email='[email protected]')
        account = Account.objects.create(user=user, name='Test Account', balance=1000.00)
        category = Category.objects.create(name='Test Category')
        form_data = {
            'account': account.id,
            'category': category.id,
            'amount': 50.00,
            'date': '2024-02-01',
            'description': 'Test Form Transaction'
        }
        form = TransactionForm(data=form_data)
        self.assertTrue(form.is_valid())


    def test_form_invalid_data(self):
        form_data = {
            'amount': 'invalid_amount',  # Data invalid untuk amount
            'date': '2024-02-01',
            'description': 'Test Form Transaction'
        }
        form = TransactionForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn('account', form.errors)
        self.assertIn('category', form.errors)
        self.assertIn('amount', form.errors)
```

 

Penjelasan:

`test_form_valid_data` memeriksa apakah form dengan data valid diterima oleh form dan dianggap valid.

`test_form_invalid_data` memeriksa apakah form dengan data invalid ditolak dan menghasilkan error yang sesuai.

 

Deployment ke Server

Setelah Anda mengembangkan aplikasi keuangan pribadi menggunakan Django dan memastikan bahwa aplikasi tersebut berfungsi dengan baik melalui testing dan debugging, langkah selanjutnya adalah deployment ke server. Deployment adalah proses memindahkan aplikasi Anda dari lingkungan pengembangan ke lingkungan produksi di mana aplikasi tersebut dapat diakses oleh pengguna akhir. Dalam bagian ini, kita akan membahas cara menyiapkan aplikasi untuk deployment serta langkah-langkah untuk menggunakan platform hosting seperti Heroku.

 

10.1. Menyiapkan Aplikasi untuk Deployment

Sebelum melakukan deployment, Anda perlu melakukan beberapa konfigurasi penting untuk memastikan bahwa aplikasi Anda siap untuk lingkungan produksi. Konfigurasi ini melibatkan pengaturan keamanan, kinerja, dan kompatibilitas aplikasi. Berikut adalah beberapa langkah yang perlu Anda lakukan:

 

  1. Mengatur Pengaturan Produksi

Pengaturan produksi berbeda dari pengaturan pengembangan dan fokus pada keamanan, kinerja, dan stabilitas aplikasi. Beberapa pengaturan penting yang perlu diubah di file `settings.py` adalah:

 

DEBUG:

  • Setel `DEBUG` ke `False` untuk menonaktifkan mode debug. Mode debug tidak boleh diaktifkan di lingkungan produksi karena dapat mengungkapkan informasi sensitif kepada pengguna.

 

 ```python
  DEBUG = False
  ```

 

ALLOWED_HOSTS:

  • Tambahkan domain atau alamat IP yang diizinkan untuk mengakses aplikasi Anda. Ini adalah pengaturan keamanan untuk mencegah permintaan dari sumber yang tidak sah.

 

 ```python
  ALLOWED_HOSTS = ['your-domain.com', 'www.your-domain.com']
  ```

 

SECRET_KEY:

  • Pastikan `SECRET_KEY` Anda aman dan tidak terpublikasi. Anda bisa menghasilkan `SECRET_KEY` baru menggunakan Django atau generator kunci aman lainnya.

  

```python
  SECRET_KEY = 'your-very-secret-key'
  ```

 

DATABASES:

  • Jika Anda menggunakan PostgreSQL atau database lain di lingkungan produksi, konfigurasikan pengaturan basis data di `settings.py`. Untuk SQLite, Anda mungkin tidak perlu mengubah pengaturan ini.

  

```python
  DATABASES = {
      'default': {
          'ENGINE': 'django.db.backends.postgresql',
          'NAME': 'your_database_name',
          'USER': 'your_database_user',
          'PASSWORD': 'your_database_password',
          'HOST': 'your_database_host',
          'PORT': 'your_database_port',
      }
  }
  ```

 

Static Files:

  • Konfigurasi pengumpulan file statis yang diperlukan untuk aplikasi Anda, seperti CSS dan JavaScript.

 

 ```python
  STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
  ```

 

Media Files:

  • Atur lokasi penyimpanan file media, seperti gambar atau dokumen yang diunggah pengguna.

  

```python
  MEDIA_URL = '/media/'
  MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
  ```

 

  1. Menyiapkan File Konfigurasi untuk Server

Procfile:

  • Di Heroku, file ini digunakan untuk mendefinisikan perintah yang diperlukan untuk menjalankan aplikasi Django. Buat file bernama `Procfile` di root direktori proyek Anda dengan konten berikut:

  

```
  web: gunicorn personal_finance.wsgi --log-file -
  ```

 

  • `gunicorn` adalah server WSGI yang digunakan untuk menjalankan aplikasi Django di lingkungan produksi.

 

requirements.txt:

Pastikan `requirements.txt` Anda berisi semua dependensi yang dibutuhkan untuk aplikasi. Anda dapat membuat atau memperbarui file ini dengan menjalankan:

 

 ```bash
  pip freeze > requirements.txt
  ```

 

runtime.txt:

  • Tentukan versi Python yang akan digunakan di Heroku. Buat file bernama `runtime.txt` dengan konten berikut:

 

 ```
  python-3.10.0
  ```

 

  • Gantilah dengan versi Python yang sesuai dengan yang Anda gunakan di pengembangan.

 

.env:

  • File ini berisi variabel lingkungan sensitif, seperti `SECRET_KEY`, dan tidak termasuk dalam kontrol versi. Di Heroku, Anda akan mengatur variabel lingkungan melalui dashboard atau CLI.

  

```plaintext
  SECRET_KEY=your-very-secret-key
  DATABASE_URL=postgres://your_database_user:your_database_password@your_database_host:your_database_port/your_database_name
  ```

 

10.2. Menggunakan Platform Hosting

Setelah menyiapkan aplikasi, Anda siap untuk melakukan deployment ke platform hosting. Heroku adalah salah satu platform hosting yang populer untuk aplikasi Django. Berikut adalah langkah-langkah untuk melakukan deployment ke Heroku:

 

  1. Membuat Akun Heroku dan Menginstal CLI

Daftar Akun Heroku:

  • Jika Anda belum memiliki akun, daftar di [Heroku](https://signup.heroku.com/) untuk membuat akun gratis.

 

Instal Heroku CLI:

  • Unduh dan instal Heroku CLI dari [Heroku CLI Downloads](https://devcenter.heroku.com/articles/heroku-cli#download-and-install). CLI ini memungkinkan Anda untuk berinteraksi dengan Heroku dari terminal.

 

 ```bash
  # Untuk macOS
  brew tap heroku/brew && brew install heroku


  # Untuk Windows
  # Download dan jalankan installer dari https://devcenter.heroku.com/articles/heroku-cli#windows
  ```

 

  1. Login ke Heroku CLI

Login:

  • Buka terminal atau command prompt dan jalankan perintah berikut untuk login ke akun Heroku Anda:

  

```bash
  heroku login
  ```

 

  1. Membuat Aplikasi di Heroku

Membuat Aplikasi:

  • Jalankan perintah berikut untuk membuat aplikasi baru di Heroku. Heroku akan memberikan nama unik untuk aplikasi Anda jika Anda tidak menyediakannya.

  

```bash
  heroku create
  ```

 

  1. Menambahkan Remote Heroku ke Git Repository

Menambahkan Remote:

  • Heroku CLI secara otomatis menambahkan remote `heroku` ke repositori Git Anda saat Anda menjalankan `heroku create`. Verifikasi dengan perintah:

  

```bash
  git remote -v
  ```

 

  1. Mendorong Kode ke Heroku

Push ke Heroku:

  • Kirimkan kode aplikasi Anda ke Heroku dengan perintah berikut:

 

 ```bash
  git push heroku main
  ```

 

Menyinkronkan Database:

  • Setelah mendorong kode, jalankan migrasi untuk menyiapkan basis data di Heroku:

 

 ```bash
  heroku run python manage.py migrate
  ```

 

Mengumpulkan Static Files:

  • Kumpulkan file statis untuk produksi:

 

 ```bash
  heroku run python manage.py collectstatic
  ```

 

  1. Mengonfigurasi Variabel Lingkungan

Menambahkan Variabel Lingkungan:

  • Setel variabel lingkungan di Heroku menggunakan perintah berikut:
 ```bash
  heroku config:set SECRET_KEY=your-very-secret-key
  heroku config:set DATABASE_URL=postgres://your_database_user:your_database_password@your_database_host:your_database_port/your_database_name
  ```

 

  1. Mengakses Aplikasi

Akses Aplikasi:

  • Setelah deployment selesai, Anda dapat mengakses aplikasi Anda melalui URL yang diberikan oleh Heroku:

 

 ```bash
  heroku open
  ```

 

  1. Monitoring dan Logging

Melihat Log Aplikasi:

  • Untuk memantau log aplikasi dan memastikan bahwa semuanya berjalan dengan baik, gunakan:

 

 ```bash
  heroku logs --tail
  ```

 

Itulah tadi step by step membuat aplikasi keuangan Menggunakan phyton dan django

Series: HTML
Published on June 30, 2024
Last updated on June 03, 2026
Tutorials
Java Script java HTML Python css
Previous Cara Memulai Jasa Asisten Virtual
Next Serba-serbi Bahasa Pemrograman C

If you like this post and want to support us, you can support us via buymeacoffee or trakteer.

trakteer divisidev divisidev: buy me a coffee