Bab 1

1.1 PENDAHULUAN

1.1.1 Golang

Go, juga dikenal sebagai Golang, adalah sebuah bahasa pemrograman yang dikembangkan oleh
Google dengan tujuan menyediakan produktivitas pemrograman yang tinggi dan kinerja yang baik.
Diluncurkan ke publik pada tahun 2009, Go dirancang untuk menggabungkan sederhana, efisiensi,
dan kemampuan untuk mengelola program yang kompleks. Go didesain dengan fokus pada
kecepatan kompilasi dan eksekusi, serta pengembangan perangkat lunak skala besar. Bahasa ini
menawarkan sintaksis yang sederhana dan mudah dipahami, dengan tipe data statis dan sistem
modul yang memudahkan pengelolaan dependensi. Salah satu fitur kunci dari Go adalah
kemampuannya dalam pemrograman konkuren. Dengan menggunakan goroutine dan channel, Go
memungkinkan pengembang untuk menulis kode yang efisien dalam menghadapi tugas-tugas
konkuren. Hal ini membuat Go menjadi pilihan yang populer dalam pengembangan aplikasi yang
membutuhkan kecepatan dan skalabilitas.

Go juga memiliki ekosistem yang berkembang dengan dukungan komunitas yang kuat. Terdapat
banyak pustaka dan kerangka kerja yang telah dibangun dengan Go, memudahkan pengembang
untuk membangun aplikasi dengan cepat dan efisien. Dengan fitur-fitur yang kuat, performa yang
baik, dan dukungan komunitas yang aktif, Go telah menjadi bahasa pemrograman yang diminati oleh
para pengembang di berbagai bidang. Dalam panduan ini, kami akan menjelajahi lebih lanjut tentang
fitur-fitur bahasa Go dan memberikan wawasan tentang bagaimana memanfaatkannya dalam
pengembangan perangkat lunak modern.

1.1.2 Clean Arsitektur

Clean Architecture adalah sebuah pendekatan desain perangkat lunak yang populer dan sering
digunakan dalam pengembangan aplikasi menggunakan bahasa pemrograman Go (Golang).
Pendekatan ini bertujuan untuk memisahkan dan mengorganisir kode secara terstruktur agar lebih
mudah dipahami, diuji, dan dikelola. Clean Architecture menekankan pemisahan antara logika bisnis
inti (core business logic) dengan implementasi teknis atau detail infrastruktur. Dengan cara ini,
aplikasi dapat tetap terisolasi dari perubahan teknologi atau alat yang digunakan, sehingga lebih
fleksibel dan mudah dimodifikasi. Dalam Clean Architecture, kode dibagi menjadi beberapa lapisan
dengan tanggung jawab yang terdefinisi dengan jelas. Beberapa lapisan yang umumnya digunakan
dalam Clean Architecture meliputi:

- Lapisan Entitas (Entities): Lapisan ini berisi definisi model atau struktur data yang
merepresentasikan entitas bisnis utama dalam aplikasi. Entitas-entitas ini harus independen
dari detail teknis atau implementasi infrastruktur.
- Lapisan Penggunaan (Use Cases): Lapisan ini berisi implementasi logika bisnis aplikasi. Use
cases mengandung aturan bisnis spesifik dan interaksi antara entitas-entitas dalam aplikasi.
Lapisan ini fokus pada pemrosesan data dan pengambilan keputusan berdasarkan aturan
bisnis.
- Lapisan Interface (Interfaces): Lapisan ini menyediakan antarmuka atau kontrak yang
menghubungkan lapisan penggunaan dengan lapisan infrastruktur. Interfaces mendefinisikan
cara komponen-komponen aplikasi berinteraksi satu sama lain. Hal ini memungkinkan
 fleksibilitas dalam mengganti implementasi infrastruktur tanpa mempengaruhi lapisan
penggunaan.
- Lapisan Infrastruktur (Infrastructure): Lapisan ini bertanggung jawab untuk implementasi
teknis dan detail infrastruktur seperti basis data, komunikasi jaringan, penyimpanan data,
dan sebagainya. Lapisan ini menyediakan implementasi konkrit dari interface yang
didefinisikan di lapisan interface.

Dengan menggunakan Clean Architecture, aplikasi Go menjadi lebih terstruktur, mudah diuji, dan
memiliki batasan-batasan yang jelas antara lapisan-lapisan. Selain itu, Clean Architecture juga
memfasilitasi pengembangan tim yang terorganisir dan meningkatkan kualitas perangkat lunak
secara keseluruhan. Dalam panduan ini, kami akan menjelaskan konsep-konsep dan prinsip-prinsip
Clean Architecture secara mendalam, serta memberikan contoh pengimplementasiannya dalam
aplikasi Go.

1.1.3 Mongo DB

MongoDB adalah salah satu sistem manajemen basis data NoSQL yang populer, sedangkan Golang
(Go) adalah bahasa pemrograman yang efisien dan kuat. Kombinasi dari kedua teknologi ini
memberikan pengembang kemampuan untuk membangun aplikasi yang skalabel dan efisien.
MongoDB menggunakan model penyimpanan dokumen yang fleksibel, yang memungkinkan
pengelolaan data yang tidak terstruktur dengan mudah. Dengan MongoDB, Anda dapat menyimpan
dan mengakses data dalam bentuk dokumen JSON yang terstruktur. Ini memungkinkan
pengembangan aplikasi yang mudah beradaptasi dengan perubahan kebutuhan bisnis. Golang,
dengan kecepatan eksekusi yang tinggi dan pengelolaan memori yang efisien, merupakan bahasa
pemrograman yang ideal untuk mengembangkan aplikasi yang memanfaatkan MongoDB. Golang
menyediakan driver resmi untuk MongoDB yang memungkinkan pengguna berinteraksi dengan basis
data MongoDB menggunakan Golang. Dengan driver ini, Anda dapat melakukan operasi dasar seperti
menyisipkan, mengambil, memperbarui, dan menghapus data dari MongoDB.

Penggunaan Golang dengan MongoDB memberikan keuntungan dalam hal skalabilitas, performa,
dan keandalan. Kombinasi ini memungkinkan pengembang untuk dengan mudah membangun
aplikasi yang dapat mengelola data dengan cepat dan efisien. Dalam panduan ini, kami akan
membahas penggunaan MongoDB dengan Golang. Kami akan menjelaskan cara mengatur koneksi ke
basis data MongoDB, melakukan operasi CRUD (Create, Read, Update, Delete), dan menggunakan
fitur-fitur MongoDB lainnya seperti indeks dan agregasi data. Kami juga akan memberikan contoh
pengkodean yang jelas dan langkah-langkah praktis untuk membantu Anda memulai dengan
pengembangan aplikasi Golang dan MongoDB. Dengan menggunakan MongoDB dan Golang
bersama-sama, Anda akan memiliki alat yang kuat untuk mengembangkan aplikasi yang tangguh,
skalabel, dan efisien.

1.1.4 Js & Go

JavaScript (JS) dan Golang (Go) adalah dua bahasa pemrograman yang berbeda yang menawarkan
keunggulan masing-masing dan dapat saling melengkapi dalam pengembangan aplikasi. Kombinasi JS
dan Golang memungkinkan pengembang memanfaatkan kelebihan dari kedua bahasa untuk
membangun sistem yang kompleks dan efisien. JavaScript, sebagai bahasa pemrograman yang
banyak digunakan dalam pengembangan web, sangat baik dalam menciptakan antarmuka pengguna
(UI) yang interaktif dan aplikasi web yang responsif. Dengan dukungan luas dari browser web
modern, JavaScript memungkinkan pengembang untuk menciptakan pengalaman pengguna yang
menarik secara visual dan dinamis. Di sisi lain, Golang adalah bahasa pemrograman yang kuat dan
efisien yang dirancang untuk performa tinggi dan pengelolaan memori yang efektif. Golang sangat
cocok untuk membangun aplikasi sisi server, pemrosesan data, dan layanan backend yang dapat
skalabel. Dengan kecepatan eksekusi yang cepat, Golang cocok digunakan untuk aplikasi yang
membutuhkan pemrosesan yang intensif. Dengan menggabungkan JS dan Golang, pengembang
dapat memanfaatkan kelebihan masing-masing bahasa untuk membangun aplikasi yang
komprehensif. Misalnya, JS dapat digunakan untuk mengembangkan antarmuka pengguna interaktif
di sisi klien, sementara Golang dapat menangani logika bisnis, pemrosesan data, dan komunikasi
basis data di sisi server.

Penggunaan Golang di sisi server menawarkan keuntungan dalam hal skalabilitas dan efisiensi.
Dengan fitur bahasa yang kuat dan dukungan bawaan untuk konkurensi, Golang memungkinkan
pengembang membangun sistem yang dapat menangani beban tinggi dengan efektif. Dalam
panduan ini, kami akan menjelajahi cara menggunakan JS dan Golang secara bersama-sama dalam
pengembangan aplikasi. Kami akan membahas integrasi antara JS dan Golang, penggunaan
WebSocket untuk komunikasi real-time, kompilasi kode Golang ke JavaScript menggunakan
GopherJS, serta berbagai alat dan kerangka kerja yang dapat membantu dalam pengembangan
aplikasi dengan kombinasi ini. Dengan menggabungkan kekuatan JavaScript dan Golang, Anda dapat
mengembangkan aplikasi yang menawarkan antarmuka pengguna interaktif dan responsif di sisi
klien, sambil mendapatkan kinerja tinggi dan keandalan di sisi server. Kombinasi ini memberikan
fleksibilitas dan efisiensi dalam pengembangan aplikasi modern.

1.1.5 Rest API & Restful API

Dalam pengembangan Golang, REST API dan RESTful API telah menjadi pendekatan yang sangat
populer. Dengan menggunakan bahasa pemrograman Go, Anda dapat membangun layanan backend
yang efisien dan terhubung dengan mudah melalui protokol HTTP. REST API adalah gaya arsitektur
perangkat lunak yang mengikuti prinsip-prinsip REST (Representational State Transfer). Prinsip utama
REST adalah pemisahan antara antarmuka dan data, serta menggunakan metode HTTP yang sesuai
seperti GET, POST, PUT, dan DELETE untuk berinteraksi dengan sumber daya (resources). RESTful API,
di sisi lain, mengacu pada implementasi praktis dari prinsip-prinsip REST dalam pengembangan API.
RESTful API dirancang untuk memenuhi prinsip-prinsip tersebut, termasuk identifikasi sumber daya
melalui URI, komunikasi melalui representasi yang dapat dimengerti (seperti JSON atau XML), serta
tidak menyimpan status klien di server. Dalam pengembangan REST API dan RESTful API
menggunakan Golang, Anda dapat menggunakan paket "net/http" yang disediakan oleh bahasa Go
untuk menangani permintaan dan respons HTTP. Anda dapat membuat handler untuk setiap
endpoint yang ingin Anda buat, dan menggunakan metode HTTP yang sesuai untuk mengelola
operasi CRUD.

Selain itu, Go juga menyediakan kerangka kerja (framework) seperti "Gin" atau "Echo" yang dapat
mempermudah dalam membangun REST API. Kerangka kerja ini menyediakan fitur-fitur seperti
routing, middleware, dan pengelolaan permintaan HTTP dengan lebih efisien. Dalam pengembangan
REST API, penting untuk memperhatikan praktik terbaik seperti penggunaan status kode HTTP yang
tepat, autentikasi dan otorisasi pengguna, penggunaan format data yang umum seperti JSON, serta
pengujian dan dokumentasi yang baik untuk API yang dibangun. Dengan menggabungkan kekuatan
bahasa Go dan konsep REST API, Anda dapat mengembangkan aplikasi web yang efisien, mudah
digunakan, dan terhubung dengan baik dengan berbagai klien yang berbeda. Dengan penggunaan
yang tepat, REST API dalam bahasa Go dapat membantu Anda membangun layanan backend yang
handal dan responsif.

1.2 Identifikasi masalah

Dalam pembahasan tentang pengembangan aplikasi kasir berbasis Restful API menggunakan Golang
dengan penerapan Clean Architecture dan penggunaan MongoDB sebagai basis data, terdapat
beberapa identifikasi masalah yang perlu diperhatikan, antara lain:

1. Kompleksitas Arsitektur: Penjelasan yang tidak mendetail mengenai struktur arsitektur yang
digunakan dapat menyebabkan kebingungan dan ketidakjelasan dalam pengembangan
aplikasi. Informasi yang lebih rinci mengenai komponen-komponen arsitektur dan
hubungannya akan membantu pengembang memahami dengan lebih baik.
2. Keterbatasan Informasi: Pembahasan yang kurang rinci mengenai cara kerja aplikasi kasir dan
fitur-fitur yang diimplementasikan dapat membatasi pemahaman tentang konteks
pengembangan aplikasi. Informasi yang lebih lengkap mengenai alur kerja, use case, dan
fitur-fitur yang akan dikembangkan akan memberikan gambaran yang lebih jelas.
3. Integrasi MongoDB: Penjelasan yang kurang detail mengenai integrasi MongoDB ke dalam
aplikasi kasir menyebabkan ketidakjelasan mengenai pengaturan koneksi, operasi CRUD, dan
manajemen transaksi dengan MongoDB. Informasi yang lebih rinci mengenai integrasi ini
akan mempermudah pengembang dalam mengimplementasikan dan mengelola basis data.
4. Kurangnya Contoh Kode: Kekurangan contoh kode konkret yang menggambarkan
implementasi aplikasi kasir dengan Clean Architecture menggunakan Golang dan MongoDB
dapat menyulitkan pemahaman. Contoh kode yang jelas dan terstruktur akan membantu
pengembang dalam memahami cara implementasi yang benar dan efektif.
5. Pengujian dan Keamanan: Tidak adanya pembahasan mengenai pengujian aplikasi dan
implementasi keamanan pada aplikasi kasir dapat mengabaikan aspek penting dalam
pengembangan. Pengujian yang baik dan implementasi keamanan yang tepat akan
memastikan aplikasi memiliki kualitas yang baik dan terhindar dari kerentanan keamanan.

1.4 Tujuan

Berdasarkan identifikasi masalah yang telah disebutkan sebelumnya, tujuan dari penelitian ini
adalah:

1. Menganalisis dan merancang struktur arsitektur yang jelas dan terstruktur untuk
pengembangan aplikasi kasir berbasis Restful API menggunakan Golang dengan penerapan
Clean Architecture.
2. Mengidentifikasi dan menjelaskan secara rinci cara kerja aplikasi kasir serta fitur-fitur yang
akan diimplementasikan dalam konteks pengembangan.
3. Meneliti dan mengimplementasikan integrasi MongoDB secara detail ke dalam aplikasi kasir,
termasuk pengaturan koneksi, operasi CRUD, dan manajemen transaksi dengan MongoDB.
 4. Menyediakan contoh kode konkret yang menggambarkan implementasi aplikasi kasir dengan
Clean Architecture menggunakan Golang dan MongoDB, sehingga pengembang dapat
memahami cara implementasi yang benar dan efektif.
5. Membahas dan menerapkan pengujian aplikasi serta implementasi keamanan yang tepat
pada aplikasi kasir, untuk memastikan kualitas, keandalan, dan keamanan aplikasi yang
dikembangkan.

Dengan mencapai tujuan-tujuan tersebut, penelitian ini bertujuan untuk memberikan panduan dan
pemahaman yang jelas bagi para pengembang dalam mengembangkan aplikasi kasir berbasis Restful
API menggunakan Golang dengan penerapan Clean Architecture dan penggunaan MongoDB sebagai
basis data.

Bab 2

2.1 Landasan Teori

Objek aplikasi kasir berbasis Restful API menggunakan Golang dengan penerapan Clean Architecture
dan penggunaan MongoDB sebagai basis data didukung oleh beberapa teori dan konsep yang
relevan. Landasan teori ini memberikan pemahaman yang lebih mendalam tentang prinsip-prinsip
yang mendasari pengembangan aplikasi kasir dengan pendekatan tersebut. Beberapa teori yang
menjadi landasan dalam penelitian ini antara lain:

A. Restful API

Restful API adalah pendekatan dalam desain dan pengembangan aplikasi web yang mengikuti
prinsip-prinsip Representational State Transfer (REST). Teori ini menjelaskan tentang desain API yang
memanfaatkan protokol HTTP dan metode CRUD (Create, Read, Update, Delete) untuk berinteraksi
dengan sumber daya (resource) dalam aplikasi. Sumber rujukan: Roy Fielding, "Architectural Styles
and the Design of Network-based Software Architectures," University of California, Irvine (2000).

B. Clean Architecture

Clean Architecture adalah konsep arsitektur perangkat lunak yang menekankan pemisahan antara
lapisan bisnis (domain) dengan infrastruktur dan detail teknis lainnya. Teori ini menjelaskan tentang
prinsip SOLID (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation,
Dependency Inversion) dan penggunaan pola desain seperti Dependency Injection untuk mencapai
arsitektur yang bersih dan terstruktur. Sumber rujukan: Robert C. Martin, "Clean Architecture: A
Craftsman's Guide to Software Structure and Design," Prentice Hall (2017).

C. MongoDB

MongoDB adalah basis data NoSQL yang menggunakan model dokumen untuk menyimpan dan
mengelola data. Teori ini menjelaskan tentang konsep dasar MongoDB, seperti koleksi, dokumen,
indeks, dan operasi CRUD yang dilakukan dengan menggunakan bahasa kueri JSON-like. Sumber
rujukan: Shannon Bradshaw, Eoin Brazil, and Kristina Chodorow, "MongoDB: The Definitive Guide,"
O'Reilly Media (2013).

D. Golang

Golang adalah bahasa pemrograman yang dikembangkan oleh Google dengan fokus pada efisiensi,
keandalan, dan kesederhanaan. Teori ini menjelaskan tentang fitur-fitur utama Golang, seperti tipe
data, struktur kontrol, fungsi, pengelolaan package, dan kemampuan konkurensi yang dimiliki oleh
bahasa ini. Sumber rujukan: Donovan Alan A.A. and Kernighan Brian W., "The Go Programming
Language," Addison-Wesley Professional (2015).

Bab 3

3.1 Analisis Kebutuhan Fungsional dan Non Fungsional

3.1.1 Kebutuhan Fungsional

Dalam analisis kebutuhan fungsional untuk aplikasi kasir berbasis Restful API menggunakan Golang
dengan penerapan Clean Architecture dan penggunaan MongoDB sebagai basis data, beberapa fitur
utama yang perlu diperhatikan adalah:

1. Manajemen Produk: Aplikasi harus memiliki kemampuan untuk menambahkan, mengedit,

dan menghapus data produk. Informasi produk yang perlu disimpan termasuk nama produk,
harga, stok, dan detail produk lainnya.
2. Pencatatan Transaksi: Aplikasi harus dapat mencatat transaksi penjualan, termasuk produk
yang terjual, jumlah produk yang dibeli, harga total, dan waktu transaksi.
3. Pembuatan Laporan: Aplikasi harus mampu menghasilkan laporan penjualan, seperti laporan
harian, mingguan, atau bulanan. Laporan ini dapat mencakup informasi seperti total
penjualan, produk terlaris, dan tren penjualan.
4. Manajemen Pengguna: Aplikasi harus memiliki fitur untuk mendaftar pengguna baru,
mengelola akun pengguna, dan mengatur tingkatan akses pengguna sesuai dengan peran
mereka dalam sistem.

3.1.2 Kebutuhan Non Fungsional

Selain kebutuhan fungsional, ada juga kebutuhan non fungsional yang harus dipertimbangkan dalam
pengembangan aplikasi kasir ini:

1. Kinerja: Aplikasi harus responsif dan mampu menangani beban pengguna yang tinggi. Waktu
respon yang cepat dan ketersediaan sistem yang tinggi adalah faktor penting dalam
memastikan pengalaman pengguna yang baik.
2. keamanan: Aplikasi harus memiliki langkah-langkah keamanan yang memadai, termasuk
otentikasi pengguna, enkripsi data, dan perlindungan terhadap serangan yang umum, seperti
serangan injeksi SQL atau cross-site scripting (XSS).
3. Skalabilitas: Aplikasi harus dirancang untuk dapat dengan mudah ditingkatkan dan diperluas
ke depannya, sehingga dapat mengakomodasi pertumbuhan bisnis dan volume pengguna
yang lebih besar.
 4. Dokumentasi: Aplikasi harus didokumentasikan dengan baik, termasuk panduan instalasi,
penggunaan, dan pengembangan. Dokumentasi yang lengkap akan membantu pengguna
dan pengembang dalam memahami dan menggunakan aplikasi dengan benar.

Bab 4

4.1 Sample Code

Controller/orderController.go

package controller

import (
"context"
"fmt"
"golang-restaurant-management/database"
"golang-restaurant-management/models"
"log"
"net/http"
"time"

"github.com/gin-gonic/gin"

"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)

var ctx, cancel = context.WithTimeout(context.Background(),

100*time.Second)

// var menuCol *mongo.Collection =

database.OpenCollection(database.Client, "menu")
var orderCollection *mongo.Collection =
database.OpenCollection(database.Client, "order")

func GetOrders() gin.HandlerFunc {

return func(c *gin.Context) {
var ctx, cancel = context.WithTimeout(context.Background(),
100*time.Second)
 result, err := orderCollection.Find(context.TODO(),
bson.M{})
defer cancel()
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error":
"error occured while listing order items"})
}
var allOrders []bson.M
if err = result.All(ctx, &allOrders); err != nil {
log.Fatal(err)
}
c.JSON(http.StatusOK, allOrders)
}
}

func GetOrder() gin.HandlerFunc {

return func(c *gin.Context) {
var ctx, cancel = context.WithTimeout(context.Background(),
100*time.Second)
orderId := c.Param("order_id")
var order models.Order

err := orderCollection.FindOne(ctx, bson.M{"order_id":

orderId}).Decode(&order)
defer cancel()
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error":
"error occured while fetching the orders"})
}
c.JSON(http.StatusOK, order)
}
}

func CreateOrder() gin.HandlerFunc {

return func(c *gin.Context) {
var table models.Table
var order models.Order

if err := c.BindJSON(&order); err != nil {

c.JSON(http.StatusBadRequest, gin.H{"error":
err.Error()})
return
 }

validationErr := validate.Struct(order)

if validationErr != nil {
c.JSON(http.StatusBadRequest, gin.H{"error":
validationErr.Error()})
return
}

tableCollection := database.OpenCollection(database.Client,
"table")

ctx, cancel := context.WithTimeout(context.Background(),

100*time.Second) // Tambahkan ini

if order.Table_id != nil {
err := tableCollection.FindOne(ctx, bson.M{"table_id":
*order.Table_id}).Decode(&table)
if err != nil {
msg := fmt.Sprintf("message:Table was not found")
c.JSON(http.StatusInternalServerError,
gin.H{"error": msg})
cancel() // Batalkan konteks jika terjadi kesalahan
return
}
}

order.Created_at, _ = time.Parse(time.RFC3339,
time.Now().Format(time.RFC3339))
order.Updated_at, _ = time.Parse(time.RFC3339,
time.Now().Format(time.RFC3339))

order.ID = primitive.NewObjectID()
order.Order_id = order.ID.Hex()

result, insertErr := orderCollection.InsertOne(ctx, order)

if insertErr != nil {
msg := fmt.Sprintf("order item was not created")
c.JSON(http.StatusInternalServerError, gin.H{"error":
msg})
 cancel() // Batalkan konteks jika terjadi kesalahan
return
}

defer cancel()
c.JSON(http.StatusOK, result)
}
}

func UpdateOrder() gin.HandlerFunc {

return func(c *gin.Context) {
var table models.Table
var order models.Order

var updateObj primitive.D

orderId := c.Param("order_id")
if err := c.BindJSON(&order); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error":
err.Error()})
return
}

if order.Table_id != nil {
err := menuCollection.FindOne(ctx, bson.M{"tabled_id":
order.Table_id}).Decode(&table)
defer cancel()
if err != nil {
msg := fmt.Sprintf("message:Menu was not found")
c.JSON(http.StatusInternalServerError,
gin.H{"error": msg})
return
}
updateObj = append(updateObj, bson.E{"menu",
order.Table_id})
}

order.Updated_at, _ = time.Parse(time.RFC3339,
time.Now().Format(time.RFC3339))
updateObj = append(updateObj, bson.E{"updated_at",
order.Updated_at})
 upsert := true

filter := bson.M{"order_id": orderId}

opt := options.UpdateOptions{
Upsert: &upsert,
}

result, err := orderCollection.UpdateOne(

ctx,
filter,
bson.D{
{"$set", updateObj},
},
&opt,
)

if err != nil {
msg := fmt.Sprintf("order item update failed")
c.JSON(http.StatusInternalServerError, gin.H{"error":
msg})
return
}

defer cancel()
c.JSON(http.StatusOK, result)
}
}

// //////////////////////// delete order

// DeleteOrder handles the deletion of an order
func DeleteOrder() gin.HandlerFunc {
return func(c *gin.Context) {
orderID := c.Param("order_id")

// Create a filter to match the order_id field

filter := bson.M{"order_id": orderID}

// Delete the order

result, err := orderCollection.DeleteOne(context.TODO(),
filter)
if err != nil {
log.Println("Error deleting order:", err)
 c.JSON(http.StatusInternalServerError, gin.H{"error":
"terjadi kesalahan saat menghapus pesanan"})
return
}

// Check the result to determine if the order was deleted

if result.DeletedCount == 0 {
c.JSON(http.StatusNotFound, gin.H{"error": "pesanan
tidak ditemukan"})
return
}

c.JSON(http.StatusOK, gin.H{"message": "pesanan berhasil

dihapus"})
}
}

func OrderItemOrderCreator(order models.Order) string {

order.Created_at, _ = time.Parse(time.RFC3339,
time.Now().Format(time.RFC3339))
order.Updated_at, _ = time.Parse(time.RFC3339,
time.Now().Format(time.RFC3339))
order.ID = primitive.NewObjectID()
order.Order_id = order.ID.Hex()

orderCollection.InsertOne(ctx, order)
defer cancel()

return order.Order_id
}
Pada bab ini, terdapat implementasi kontroler untuk entitas "Order" dalam sistem aplikasi
manajemen restoran. Berikut adalah penjelasan mengenai fungsi-fungsi yang terdapat dalam file
OrderController.go:

1. GetOrders(): Fungsi ini digunakan untuk mengambil daftar semua pesanan yang ada dalam
sistem. Menggunakan operasi database "Find" untuk mencari semua dokumen dalam koleksi
"order" dan mengembalikan daftar pesanan dalam format JSON.

2. GetOrder(): Fungsi ini digunakan untuk mengambil data pesanan berdasarkan ID pesanan
yang diberikan. Menggunakan operasi database "FindOne" dengan filter berdasarkan
"order_id" untuk mencari dokumen pesanan yang sesuai. Data pesanan kemudian
dikembalikan dalam format JSON.
 3. CreateOrder(): Fungsi ini digunakan untuk membuat pesanan baru dalam sistem. Data
pesanan baru dikirim melalui permintaan HTTP dengan metode POST dan disimpan ke dalam
koleksi "order" dalam database. Sebelum penyimpanan, validasi struktur data pesanan
dilakukan untuk memastikan data yang diberikan sesuai dengan aturan yang ditetapkan. Jika
berhasil, data pesanan yang baru dibuat akan dikembalikan dalam format JSON.

4. UpdateOrder(): Fungsi ini digunakan untuk memperbarui pesanan yang ada dalam sistem.
Data pesanan yang diperbarui dikirim melalui permintaan HTTP dengan metode PATCH dan
diterapkan pada dokumen pesanan yang sesuai dalam koleksi "order" berdasarkan ID
pesanan yang diberikan. Sebelum pembaruan, validasi dan pengecekan keberadaan meja
yang terkait dilakukan. Jika berhasil, hasil pembaruan akan dikembalikan dalam format JSON.

5. DeleteOrder(): Fungsi ini digunakan untuk menghapus pesanan yang ada dalam sistem.
Pesanan yang akan dihapus ditentukan berdasarkan ID pesanan yang diberikan.
Menggunakan operasi database "DeleteOne" dengan filter berdasarkan "order_id" untuk
menghapus dokumen pesanan yang sesuai. Jika berhasil menghapus pesanan, pesan sukses
akan dikembalikan dalam format JSON.

6. OrderItemOrderCreator(): Fungsi ini digunakan untuk membuat pesanan dalam sistem dan
mengembalikan ID pesanan yang baru dibuat. Fungsi ini digunakan dalam bagian lain dari
sistem yang menggabungkan fungsi ini dengan fungsi lain untuk membuat pesanan dengan
entitas terkait. Data pesanan yang baru dibuat akan disimpan dalam koleksi "order" dalam
database.

Model/orderModel.go

package models

import (
"time"

"go.mongodb.org/mongo-driver/bson/primitive"
)

type Food struct {

ID primitive.ObjectID `bson:"_id"`
Name *string `json:"name"
validate:"required,min=2,max=100"`
Price *float64 `json:"price" validate:"required"`
Food_image *string `json:"food_image"
validate:"required"`
Created_at time.Time `json:"created_at"`
Updated_at time.Time `json:"updated_at"`
Food_id string `json:"food_id"`
 Menu_id *string `json:"menu_id"
validate:"required"`
}

Pada file OrderModel.go, terdapat definisi struktur data (model) untuk entitas "Order" dalam sistem
aplikasi manajemen restoran. Berikut adalah penjelasan mengenai atribut-atribut yang terdapat
dalam struktur data Order:

1. ID: Merupakan atribut yang menyimpan ID unik dari pesanan. Tipe data yang digunakan
adalah primitive.ObjectID.

2. Order_Date: Merupakan atribut yang menyimpan tanggal dan waktu pesanan dibuat. Tipe
data yang digunakan adalah time.Time.

3. Created_at: Merupakan atribut yang menyimpan tanggal dan waktu pembuatan pesanan.
Tipe data yang digunakan adalah time.Time.

4. Updated_at: Merupakan atribut yang menyimpan tanggal dan waktu terakhir kali pesanan
diperbarui. Tipe data yang digunakan adalah time.Time.

5. Order_id: Merupakan atribut yang menyimpan ID pesanan dalam bentuk string. ID ini
digunakan sebagai identifikasi unik untuk pesanan.

6. Table_id: Merupakan atribut yang menyimpan ID meja tempat pesanan dibuat. Atribut ini
dapat berupa string yang memuat ID meja terkait dengan pesanan. Validasi "required"
diterapkan untuk memastikan bahwa meja terkait pesanan selalu ada.

Router/orderRouter.go

package routes

import (
controller "golang-restaurant-management/controllers"

"github.com/gin-gonic/gin"
)

func FoodRoutes(incomingRoutes *gin.Engine) {

incomingRoutes.GET("/foods", controller.GetFoods())
incomingRoutes.GET("/foods/:food_id", controller.GetFood())
incomingRoutes.POST("/foods", controller.CreateFood())
incomingRoutes.PATCH("/foods/:food_id", controller.UpdateFood())
incomingRoutes.DELETE("/foods/:food_id",
controller.DeleteFood())
}
Pada file routes.go, terdapat pengaturan rute (routes) yang menghubungkan URL dengan fungsi
controller yang terkait dengan entitas "OrderItem" dalam sistem aplikasi manajemen restoran.
Berikut adalah penjelasan mengenai setiap rute yang didefinisikan:

1. GET /orderItems: Rute ini digunakan untuk mengambil daftar seluruh OrderItem yang ada
dalam sistem. Fungsi controller yang terkait adalah GetOrderItems.

2. GET /orderItems/:orderItemID: Rute ini digunakan untuk mengambil informasi OrderItem

berdasarkan ID OrderItem yang diberikan. Fungsi controller yang terkait adalah
GetOrderItemByID.

3. POST /orderItems: Rute ini digunakan untuk membuat OrderItem baru. Data OrderItem
dikirim dalam bentuk body JSON pada permintaan POST. Fungsi controller yang terkait
adalah CreateOrderItem.

4. PATCH /orderItems/:orderItemID: Rute ini digunakan untuk memperbarui informasi

OrderItem berdasarkan ID OrderItem yang diberikan. Data perubahan dikirim dalam bentuk
body JSON pada permintaan PATCH. Fungsi controller yang terkait adalah UpdateOrderItem.

5. DELETE /orderItems/:orderItemID: Rute ini digunakan untuk menghapus OrderItem

berdasarkan ID OrderItem yang diberikan. Fungsi controller yang terkait adalah
DeleteOrderItem.

Main.go

package main

import (
"fmt"
"os"

middleware "golang-restaurant-management/middleware"
routes "golang-restaurant-management/routes"

"github.com/gin-gonic/gin"
)

func main() {
fmt.Println("Server is running...")
os.Setenv("restaurant",
"mongodb+srv://zakymuhammadyusuf:zaky123@zaky.oy6yt60.mongodb.net/")
port := os.Getenv("PORT")

router := gin.Default()
 // Menambahkan pengaturan CORS
router.Use(func(c *gin.Context) {
c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
c.Writer.Header().Set("Access-Control-Allow-Methods", "GET,
POST, PUT, PATCH, DELETE, OPTIONS")
c.Writer.Header().Set("Access-Control-Allow-Headers",
"Origin, Content-Type, Authorization, token")
c.Writer.Header().Set("Access-Control-Max-Age", "86400")
if c.Request.Method == "OPTIONS" {
c.AbortWithStatus(200)
} else {
c.Next()
}
})

router.Use(gin.Logger())
routes.UserRoutes(router)
router.Use(middleware.Authentication())

routes.FoodRoutes(router)
routes.MenuRoutes(router)
routes.TableRoutes(router)
routes.OrderRoutes(router)
routes.OrderItemRoutes(router)
routes.InvoiceRoutes(router)

router.Run(":" + port)
}
Penjelasan:

1. Kode di atas merupakan implementasi utama dalam menjalankan server aplikasi yang
menggunakan framework Gin untuk mengatur rute-rute HTTP dan middleware dalam
aplikasi.

2. Pada baris ke-10, dilakukan penulisan "Server is running..." yang akan dicetak ke konsol
untuk menandakan bahwa server sedang berjalan.

3. Pada baris ke-11, dilakukan pengaturan variabel lingkungan "restaurant" yang berisi URL
koneksi ke basis data MongoDB.

4. Pada baris ke-12, dilakukan pengambilan nilai dari variabel lingkungan "PORT" untuk
menentukan port yang akan digunakan oleh server.
 5. Pada baris ke-14, dibuat instance router menggunakan framework Gin.

6. Pada baris ke-17 hingga ke-25, ditambahkan middleware untuk mengatur CORS pada server.
Middleware ini memungkinkan akses dari domain atau sumber daya yang berbeda dan
mengatur header yang sesuai.

7. Pada baris ke-27, ditambahkan middleware untuk mencatat setiap permintaan HTTP yang
masuk ke server ke dalam log.

8. Pada baris ke-29 hingga ke-35, dilakukan pemanggilan fungsi-fungsi dari package "routes"
yang mengatur rute-rute terkait dengan entitas dalam aplikasi seperti user, food, menu,
table, order, order item, dan invoice.

9. Pada baris ke-37, dilakukan menjalankan server menggunakan port yang telah ditentukan
sebelumnya.

4.2 Uji Coba Postman

Dalam permintaan yang Anda lakukan melalui Postman, Anda menggunakan metode POST untuk
membuat pesanan baru dengan data yang relevan. Setelah melakukan permintaan, Anda menerima
respons yang berisi ID pesanan yang baru dibuat. Melalui permintaan tersebut, sistem berhasil
membuat pesanan baru dan menghasilkan ID yang dapat digunakan untuk mengidentifikasi pesanan
tersebut di dalam sistem.

Penting untuk memastikan bahwa server berjalan dengan baik dan API berfungsi sesuai harapan.
Pastikan juga data yang Anda kirimkan sesuai dengan struktur yang diharapkan oleh aplikasi agar
permintaan berhasil dieksekusi dengan benar. Apabila terdapat masalah atau kesalahan dalam
proses pembuatan pesanan, periksa kembali URL yang digunakan, pastikan server berjalan, dan
pastikan data yang dikirimkan sesuai dengan persyaratan yang ditetapkan oleh aplikasi.

Bab 5

5.1 Kesimpulan

Berdasarkan pembahasan sebelumnya mengenai pengembangan aplikasi kasir berbasis Restful API
menggunakan Golang dengan penerapan Clean Architecture dan penggunaan MongoDB sebagai
basis data, dapat disimpulkan beberapa hal sebagai berikut:

1. Dalam pengembangan aplikasi kasir, penerapan Clean Architecture sangat penting untuk
memisahkan lapisan-lapisan fungsional aplikasi dan meningkatkan skalabilitas serta
pemeliharaan kode yang lebih baik.

2. Penggunaan Golang sebagai bahasa pemrograman memberikan keunggulan dalam hal

kecepatan eksekusi dan efisiensi penggunaan sumber daya.

3. MongoDB sebagai basis data NoSQL memberikan fleksibilitas dalam menyimpan dan
mengelola data tanpa memerlukan struktur skema yang ketat.

5.2 Saran

Berdasarkan kesimpulan di atas, beberapa saran untuk pengembangan aplikasi kasir berbasis Restful
API menggunakan Golang dan MongoDB adalah sebagai berikut:

1. Perlu lebih menggali dan memahami prinsip-prinsip Clean Architecture agar dapat
menerapkannya secara efektif dalam pengembangan aplikasi kasir.

2. Sebaiknya melakukan pengujian yang komprehensif pada setiap komponen aplikasi,

termasuk pengujian integrasi antara Golang dan MongoDB, untuk memastikan kualitas dan
kinerja aplikasi.

3. Penting untuk mengikuti praktik-praktik terbaik dalam pengembangan aplikasi Restful API,
seperti menggunakan standar HTTP method dan kode status yang tepat, serta melakukan
validasi data yang masuk.

4. Melakukan pemantauan dan pemeliharaan terhadap database MongoDB secara teratur

untuk memastikan performa yang optimal dan keamanan data yang terjaga.

5. Mengimplementasikan mekanisme keamanan yang tepat, seperti otentikasi dan otorisasi,

dalam aplikasi kasir untuk melindungi data pelanggan dan transaksi yang sensitif.