LAPORAN PRAKTIKUM

PEMOGRAMAN BERORIENTASI OBJEK

“SISTEM RENTAL SEPEDA MOTOR BERBAYAR”

Disusun Oleh :

Ajeng Oktavian (1062202)

Egi Kurniawan (1062208)
Jinan Khalishah (1062214)
Lita Rahmania (1062216)
Rosaura Aulia (1062226)

2 TRPL A

Dosen : Riki Afriansyah, M.T

Pemograman Berorientasi Objek

PROGRAM STUDI D-IV TEKNOLOGI REKAYASA PERANGKAT LUNAK

POLITEKNIK MANUFAKTUR NEGERI BANGKA BELITUNG
 KATA PENGANTAR

Assalamualaikum warahmatullahi wabarokatuh.

Senantiasa kita ucapkan atas karunia-Nya berupa nikmat iman dan
kesehatan Dan tentu tidak lupa juga shalawat dan salam kita haturkan pada
junjungan kita Nabi besar Muhammad SAW. Karena berkat risalah
beliaulah yang bermanfaat bagi kita semua sehingga kita bisa seperti
sekarang.
Dan tentunya kami berterimakasih kepada semua pihak yang terlibat
dengan laporan ini, terutama kepada Bapak Riki Afriansyah,M.T yang
telah memberikan waktu sehingga kami dapat menyelesaikan laporan
praktikum ini yang berjudul Pemograman Berorientasi Objek “SISTEM
RENTAL SEPEDA MOTOR BERBAYAR”.
Tujuan dari dibuatnya laporan ini untuk memenuhi tugas mata kuliah
Pemograman Berorientasi Objek. Kami berharap semoga laporan ini dapat
memberikan manfaat bagi pembaca serta penulis.
Dengan rendah hati, kami memohon maaf apabila ada ketidaksesuaian
kalimat dan kesalahan. Meskipun demikian, kami terbuka atas kritik dan
saran dari pembaca demi kesempurnaan laporan ini.
Wassalamualaikum warahmatullahi wabarakatuh.

Sungailiat, 19 Desember 2023

 DAFTAR ISI

KATA PENGANTAR................................................................................................................ii
DAFTAR ISI.............................................................................................................................iii
BAB I PENDAHULUAN
1.1 Latar Belakang.................................................................................................................
1.2 Tujuan..............................................................................................................................
1.3 Manfaat............................................................................................................................
BAB II ISI

2.1 Studi Kasus...................................................................................................................

2.2 Teori Perkuliahan ........................................................................................................
2.3 Main. kt..........................................................................................................................
2.4 Parent (Koneksi.kt).......................................................................................................
2.5 Child (Admin.kt)...........................................................................................................
2.6 Tambahan dari Bapak...................................................................................................

BAB III PENUTUP

3.1 Kesimpulan......................................................................................................................
 BAB I
PENDAHULUAN
1.1 Latar Belakang

Dalam era modern ini, kebutuhan akan transportasi yang praktis dan efisien semakin meningkat.
Sistem penyewaan sepeda motor berbayar menjadi salah satu solusi yang populer untuk memenuhi
kebutuhan mobilitas penduduk di berbagai kota. Penyediaan layanan ini dapat membantu mengatasi
masalah kemacetan, menyediakan alternatif transportasi yang ramah lingkungan, dan memberikan
fleksibilitas kepada pengguna dalam memilih modal transportasi.
1.2 Tujuan
Pembuatan kode pemrograman untuk sistem rental sepeda motor berbayar bertujuan untuk memberikan
platform yang efisien dan user-friendly bagi penyedia layanan dan pengguna sepeda motor. Tujuan
khususnya dapat mencakup:
1. Memudahkan pengguna dalam proses pendaftaran dan penyewaan sepeda motor.
2. Menyediakan sistem pembayaran yang aman dan nyaman.
3. Memastikan ketersediaan sepeda motor yang memadai.
4. Meningkatkan efisiensi operasional penyedia layanan dengan otomatisasi manajemen sepeda
motor.

1.3 Manfaat
Pengembangan sistem rental sepeda motor berbayar memberikan berbagai manfaat, antara lain:
Kemudahan Akses:
1. Pengguna dapat dengan mudah menyewa sepeda motor tanpa harus memikirkan kepemilikan.
2. Reduksi Kemacetan: Penggunaan sepeda motor sebagai moda transportasi alternatif dapat
membantu mengurangi kemacetan di kota.
3. Ramah Lingkungan: Memotivasi penggunaan transportasi berkelanjutan dan ramah lingkungan.
4. Pengelolaan Efisien: Penyedia layanan dapat mengelola sepeda motor dengan lebih efisien
melalui otomatisasi proses pemesanan, dan pembayaran.
 BAB II
PEMBAHASAN

2.1 Studi Kasus

Sistem penyewaan sepeda motor berbayar yang di dalamnya terdapat lama sewa, info motor, info
denda dan Riwayat penyewaan.

2.2 Teori Perkuliahan

 Class, Method, Object

Dalam PBO, sebuah class merupakan blueprint untuk objek. Class berfungsi untuk menampung isi
dari program yang akan dijalankan, di dalamnya berisi atribut/type data dan method untuk
menjalankan suatu program. Method adalah fungsi yang dimiliki oleh suatu class. Object adalah
instance dari class.

 Setter dan Getter

Setter dan getter merupakan metode akses yang diguankan (setter) dan mengumpulkan (getter) nilai
atribut objek. Setter adalah sebuah aksi saat kita memasukan sebuah sebuah nilai/values kedalam
suatu variable/object, sedangkan getter adalah sebuah aksi saat kita mengambil sebuah nilai/values
dari suatu variable/object.

 Contructor
Constructor adalah metode khusus yang dipanggil saat objek suatu class dibuat. Menginisialisasi
objek dengan nilai awal atau menetapkan keadaan awalnya ini merupakan tugas utama konstruktor.
Konstruktor memiliki nama yang sama dengan nama classnya dan tidak mengembalikan nilai.

 List of Mutable
Fungsi listOf menghasilkan list yang bersifat immutable, artinya kita tidak dapat menambahkan,
menghapus, atau mengubah elemen-elemen dalam list setelah list dibuat. MutableList adalah yang
bersifat koleksi (collection) dalam Bahasa pemrograman kotlin yang digunakan untuk menyimpa
sejumlah elemen dalam urutan tertentu (sequential order) dan memungkinkan perubahan (modifikasi)
terhadap elemen-elemennya setelah list tersebut dibuat. Mutable List memungkinkan penembahan,
penghapusan, dan perubahan elemen-elemen dalam list sesuai kebutuhan.

 Pewarisan (inheritance)
Inheritance adalah salah satu konsep dasar dalam pemrograman berorientasi objek (OOP) yang
memungkinkan suatu kelas (kelas anak atau subclass) untuk mengambil sifat dan perilaku dari kelas
lain (kelas induk atau superclass). Inheritance memungkinkan pengembang untuk mengambil kembali
kode yang suda ada dalam kelas induk dan menggunakannya kembali dalam kelas anak.

 Overloading dan Overriding

Overloading adalah konsep di mana suatu class memiliki beberapa metode dengan nama yang sama,
tetapi parameter yang berbeda. Overriding terjadi ketika suatu class turunan mengganti metode dari
class induk. Keduanya memungkinkan untuk penyesuaian dan fleksibilitas dalam penggunaan
 metode.

2.3 Main.kt

lateinit var conn: Connection

lateinit var stmt: java.sql.Statement
lateinit var rs: ResultSet
val input = Scanner(System.`in`)
val scan = Scanner(System.`in`)
var nama = ""
var idUser = 0
var role = 0
var sql = ""
var loop = true

Penjelasan:

1. lateinit var conn: Connection: deklarasi variabel conn bertipe Connection yang akan digunakan
untuk membuat koneksi ke database. Penggunaan lateinit menandakan bahwa inisialisasi variabel
akan dilakukan kemudian.
2. lateinit var stmt: java.sql.Statement: deklarasi variabel stmt bertipe java.sql.Statement yang
akan digunakan untuk mengeksekusi pernyataan SQL di database.
3. lateinit var rs: ResultSet: deklarasi variabel rs bertipe ResultSet yang akan menyimpan hasil
dari eksekusi pernyataan SQL yang mengembalikan data.
4. val input = Scanner(System.in): Inisialisasi objek Scanner dengan nama input untuk menerima
masukan dari pengguna.
5. val scan = Scanner(System.in): Inisialisasi objek Scanner dengan nama scan.
6. var nama = "": Deklarasi variabel nama bertipe string yang akan digunakan untuk menyimpan
nama.
7. var idUser = 0: Deklarasi variabel idUser bertipe integer yang akan digunakan untuk menyimpan
ID pengguna.
8. var role = 0: Deklarasi variabel role bertipe integer yang akan digunakan untuk menyimpan
peran pengguna.
9. var sql = "": Deklarasi variabel sql bertipe string yang akan digunakan untuk menyimpan
pernyataan SQL.
10. var loop = true: Deklarasi variabel loop bertipe boolean yang akan digunakan untuk mengontrol
loop dalam program.
fun main(args: Array<String>) {
val JDBC_DRIVER = "com.mysql.cj.jdbc.Driver"
val DB_URL = "jdbc:mysql://localhost/motor3"
val USER = "root"
val PASS = ""
Kode ini menetapkan nilai-nilai konstan untuk driver JDBC, URL database, nama pengguna, dan
kata sandi yang kemudian akan digunakan untuk membuat koneksi ke database MySQL.

fun showMenu() {
println("\n====Silahkan Pilih Menu====")
println("1. Daftar")
println("2. Masuk")
println("0. Keluar")
println("")
print("Pilih >>> ")
try {
val pilihan: Int = input.nextLine().toInt()
when (pilihan) {
0 -> {
print("Terimakasih telah menggunakan ")
exitProcess(0) }
1 -> daftar()
2 -> masuk()
else -> println("Silahkan Pilih Menu yang Tersedia....")
}
} catch (e: Exception) {
e.printStackTrace()
}
}
Fun showMenu ini menampilkan menu untuk sistem pengguna untuk mendaftar, masuk, atau
keluar. Menu ini diimplementasikan menggunakan struktur when expression untuk menanggapi input
pengguna. Jika pengguna memilih opsi keluar (0), pesan terima kasih akan dicetak dan program akan
keluar dengan menggunakan fungsi exitProcess(0). Jika memilih opsi daftar (1), fungsi daftar() akan
dipanggil, dan jika memilih opsi masuk (2), fungsi masuk() akan dipanggil. Jika input tidak sesuai
dengan opsi yang tersedia, pesan "Silahkan Pilih Menu yang Tersedia...." akan dicetak.
fun daftar() {
try {
print("username: ")
val username = input.nextLine()
print("password: ")
val password = input.nextLine()
print("nama: ")
val nama = input.nextLine()
var tglLahir: String
println("Tanggal Lahir")
do {
print("(YYYY-MM-DD): ")
tglLahir = input.nextLine()
if (tglLahir.length != 10) {
println("Anda harus memasukkan tanggal lahir sesuai format!")
println("--------------------------------------------------")
}
 } while (tglLahir.length != 10)
print("Jenis Kelamin\n")
var jenkel: String
do {
print("(L/P):")
jenkel = input.nextLine()
} while (!(jenkel == "L" || jenkel == "P" || jenkel == "l" || jenkel
== "p"))
jenkel = if (jenkel == "L" || jenkel == "l") "Laki-laki" else
"Perempuan"
print("Alamat: ")
val alamat = input.nextLine()

val sql = "INSERT INTO users

(username,password,nama,tgl_lahir,jenis_kelamin,alamat)
VALUE('$username','$password', '$nama', '$tglLahir', '$jenkel', '$alamat')"
stmt.execute(sql)
println("Data Berhasil disimpan")

} catch (e: Exception) {

e.printStackTrace()
}
}
Fun daftar() dalam kode ini bertujuan untuk menerima input dari pengguna yang ingin
mendaftar, kemudian menyimpan informasi tersebut ke dalam sebuah database. Pengguna diminta untuk
memasukkan username, password, nama, tanggal lahir, jenis kelamin, dan alamat. Untuk memastikan
validitas input, dilakukan beberapa validasi, seperti memastikan panjang tanggal lahir sesuai format yang
diinginkan dan jenis kelamin yang dipilih hanya dapat berupa "L" atau "P". Setelah semua informasi
diterima, sebuah pernyataan SQL disusun untuk menyisipkan data pengguna ke dalam tabel database
yang sesuai. Selanjutnya, pernyataan tersebut dieksekusi, dan pesan berhasil disimpan ditampilkan.
print("Username: ")
val username = Scanner(System.`in`).nextLine()
print("Password: ")
val password = Scanner(System.`in`).nextLine()
Pengguna diminta untuk memasukkan username dan password.

val sql = "select * from users where username='$username' and

password='$password'"
rs = stmt.executeQuery(sql)
Pernyataan SQL dieksekusi untuk mengambil informasi pengguna berdasarkan username dan password
yang dimasukkan.

if (rs.next()){
nama =rs.getString("username")
idUser = rs.getInt("id")
role = rs.getInt("role")
if (role == 0){
menu()
}
else{
 Admin(DB_URL,USER,PASS).menu()
}
}else{
println("Username atau password salah")
}
Jika query menghasilkan hasil (baris data), maka informasi pengguna diambil dari hasil query.
Jika tidak, pesan kesalahan ditampilkan. Jika pengguna yang masuk memiliki peran (role) 0, fungsi
menu() dipanggil. Jika peran tidak sama dengan 0, dianggap sebagai admin, dan fungsi menu() dari kelas
Admin dipanggil.

fun menu(){
val inp = Scanner(System.`in`)
do {
println("======= SEWA MOTOR =======")
println("")
println("1. info Motor")
println("2. sewa ")
println("3. riwayat")
println("4. Pengembalian")
println()
println("0. Keluar")
println()
print("Opsi Yang Dipilih == ")
try {
val pilih=inp.nextInt()
when(pilih){
0->Keluar()
1->info_motor()
2->sewa()
3->riwayat()
4 ->pengembalian()
else -> println("silakan pilih opsi yang tersedia")
}
}catch (e:Exception){
e.printStackTrace()
}
}while (true)
}
Program ini menggunakan konsep pengulangan do-while dan switch-case untuk memungkinkan
pengguna memilih berbagai opsi, seperti mendapatkan informasi motor, melakukan proses penyewaan,
melihat riwayat penyewaan, mengembalikan motor, atau keluar dari program. Input dari pengguna
diambil menggunakan objek Scanner, dan kemudian program merespons pilihan pengguna sesuai dengan
kasus yang sesuai.
fun pengembalian() {
var sql = "select status from penyewa where id_user = $idUser AND status =
'belum selesai'"
try {
rs = stmt.executeQuery(sql)
if (rs.next()){
var sql = "select motor.harga, penyewa.lama_sewa,
users.id,motor.id_motor ,penyewa.id_penyewa, motor.jenis, tanggal from history
join penyewa on history.id_penyewa = penyewa.id_penyewa join users on
penyewa.id_user = users.id join motor on penyewa.id_motor = motor.id_motor
where penyewa.id_user = $idUser AND penyewa.status = 'belum selesai'"
rs = stmt.executeQuery(sql)
println("===== MOTOR YANG ANDA PINJAM =====")
var id_penyewa = 0
var idMotor = 0
var harga = 0
while (rs.next()){
harga = rs.getInt("harga") * rs.getInt("lama_sewa")
id_penyewa = rs.getInt("id_penyewa")
idMotor = rs.getInt("id_motor")
println("Jenis motor: ${rs.getString("jenis")}, tanggal
peminjaman ${rs.getTimestamp("tanggal")}")
}
println("Apakah anda ingin mengembalikan? [yes/no]")
val validasi = input.nextLine()
if (validasi == "yes"){
sql = "update history set tanggal_balik = current_date() where
id_penyewa = $id_penyewa"
stmt.execute(sql)
sql = "update motor set stok = stok + 1 where id_motor =
$idMotor"
stmt.execute(sql)
sql = "select lama_sewa,tanggal,tanggal_balik,denda from
history join penyewa on history.id_penyewa = penyewa.id_penyewa join motor on
penyewa.id_motor = motor.id_motor where id_user = $idUser and penyewa.status =
'belum selesai' order by penyewa.id_penyewa desc"
rs = stmt.executeQuery(sql)
rs.next()
var pengembalian = rs.getDate("tanggal_balik")
var lama = rs.getInt("denda")
sql = "select DATE_ADD('${rs.getDate("tanggal")}', interval $
{rs.getInt("lama_sewa")} day) as tanggal_semestinya;"
rs = stmt.executeQuery(sql)
rs.next()
sql = "select datediff('$pengembalian', '$
{rs.getDate("tanggal_semestinya")}') as telat"
rs = stmt.executeQuery(sql)
var harga_denda = 0
if (rs.next() && rs.getInt("telat") > 0){
harga_denda = (rs.getInt("telat") * lama)
}
sql = "update penyewa set status = 'selesai' where id_penyewa
= $id_penyewa"
stmt.execute(sql)

sql = "update history set harga = $harga, harga_denda =

$harga_denda where id_penyewa = $id_penyewa"
 stmt.execute(sql)
println("Terima kasih")
}
}
else{
println("Anda belum menyewa motor")
}
Fungsi ini melakukan serangkaian operasi database untuk mengelola pengembalian motor oleh
pengguna. Pertama, fungsi memeriksa status penyewaan pengguna untuk memastikan bahwa pengguna
memiliki penyewaan yang belum selesai. Jika iya, program menampilkan informasi motor yang dipinjam
dan meminta konfirmasi pengembalian. Jika pengguna setuju untuk mengembalikan motor, fungsi
melakukan serangkaian pembaruan database, termasuk mengupdate tanggal pengembalian, menambah
stok motor, dan menghitung denda jika ada keterlambatan pengembalian. Terakhir, fungsi menyimpan
informasi pengembalian dan menandai penyewaan sebagai selesai. Jika pengguna tidak memiliki
penyewaan yang belum selesai, program memberikan pesan bahwa pengguna belum menyewa motor.
Seluruh proses ini terkait dengan manajemen database untuk mencatat dan mengelola transaksi
penyewaan motor.
fun info_motor() {
val sql= "SELECT * FROM motor"
println("Memuat Data Motor...")
try {
rs= stmt.executeQuery(sql)

println("-------------------------------------------------------------------")
rs.next()
println("Jenis : ${rs.getString("jenis")}\n" +
"Harga/hari : ${rs.getInt("harga")}\n" +
"Ketersediaan : ${rs.getInt("stok")} unit")
ulang()
}catch (e:java.lang.Exception){
e.printStackTrace()
}
}
Fungsi ini bertujuan untuk menampilkan informasi umum mengenai motor-motor yang tersedia.
Pertama, fungsi mengeksekusi query SQL untuk mengambil data dari tabel motor dalam database. Setelah
itu, program mencetak informasi setiap motor yang ada, termasuk jenis motor, harga sewa per hari, dan
jumlah stok yang tersedia. Informasi ini ditampilkan kepada pengguna dengan format yang jelas.
Selanjutnya, fungsi memanggil fungsi ulang, yang bertanggung jawab untuk memberikan opsi tambahan
kepada pengguna atau mereset tampilan program. Dengan demikian, fungsi info_motor ini memberikan
pengguna gambaran singkat tentang jenis-jenis motor yang dapat disewa beserta informasi tarif dan
ketersediaannya, sebagai bagian dari antarmuka program penyewaan motor.
fun sewa() {
val inp = Scanner(System.`in`)
try {
var sql = "select count(*) as total from penyewa where id_user =
$idUser and status = 'belum selesai'"
rs = stmt.executeQuery(sql)
if (rs.next() && rs.getInt("total") != 0){
println("Anda sudah menyewa motor.")
}else{
print("Motor Yang Dipinjam (masukan id motor) : ")
var id_motor = inp.nextInt().toInt()
print("No Handhphone : ")
val no_hp = inp.next()
val sql2="SELECT status, jenis,harga from motor where
id_motor=$id_motor AND stok > 0"
rs= stmt.executeQuery(sql2)

if (rs.next()) {
println("\n====================")
println("Motor yang anda pinjam ${rs.getString("jenis")}")
println("Dengan kondisi motor ${rs.getString("status")} ")
println("\n====================")
print("Apakah anda ingin menyewa motor tersebut? [yes/no] ")
val validasi = input.nextLine()
when (validasi) {
"yes" -> {
println("\nSilahkan isi data dibawah ini: ")
print("Jaminan : ")
val jaminanSewa = inp.next()
print("Dimulai Tanggal : ")
val tanggal = inp.next()
print("Lama Penyewaan : ")
val lamaSewa = inp.next().toInt()
println("Dengan harga ${rs.getInt("harga") *
lamaSewa}")
println("apakah anda yakin? [yes/no] ")
var validasi = input.nextLine()
when (validasi) {
"yes" -> {
var sql = "INSERT INTO penyewa (id_user,
no_hp, id_motor, jaminan, tanggal, lama_sewa) VALUES($idUser,'$no_hp',
$id_motor,'$jaminanSewa','$tanggal','$lamaSewa')"
stmt.execute(sql)
sql = "select * from motor where id_motor =
$id_motor"
rs = stmt.executeQuery(sql)
var harga = 0
if (rs.next()){
harga = rs.getInt("harga") * lamaSewa
}
sql = "Select * from penyewa where id_user =
$idUser AND status = 'belum selesai'"
rs = stmt.executeQuery(sql)
var id_penyewa = 0
if (rs.next()){
id_penyewa = rs.getInt("id_penyewa")
}
sql = "update motor set stok = stok -1 where
id_motor = $id_motor"
stmt.execute(sql)
sql = "select penyewa.id_penyewa as id_penyewa
from penyewa join history on penyewa.id_penyewa = history.id_penyewa where
id_user = $idUser AND penyewa.status = 'belum selesai'"
stmt.execute(sql)
sql = "insert into history (id_penyewa,
tanggal_balik) values ($id_penyewa, current_date())"
stmt.execute(sql)
println(
"..............." +
"Data anda Telah di muat "
)
println("Data Anda Telah ditambahkan ")
println()
}

"no" -> println("Gagal memuat")

else -> println("Inputan yang anda masukkan
salah")
}
}

"no" -> println("Terima Kasih")

else -> println("Inputan yang anda masukkan salah")
}
}else{
println("Stok motor tidak ada")
}
}
}
Fungsi sewa untuk memproses proses penyewaan motor oleh pengguna. Pertama, fungsi ini
melakukan pengecekan apakah pengguna sudah memiliki penyewaan yang belum selesai dengan
menjalankan query SQL. Jika pengguna sudah memiliki penyewaan aktif, program memberikan pesan
bahwa pengguna sudah menyewa motor sebelumnya. Jika tidak, pengguna diminta untuk memasukkan ID
motor yang ingin disewa dan nomor handphone. Kemudian, program menjalankan query SQL untuk
mendapatkan informasi tentang motor yang dipilih, termasuk status dan harga.
Jika motor tersedia, program menampilkan informasi motor tersebut dan meminta konfirmasi dari
pengguna apakah mereka ingin menyewa motor tersebut. Jika pengguna menyetujui, program meminta
input tambahan seperti jaminan, tanggal mulai penyewaan, dan lama penyewaan. Setelah itu, program
menghitung harga total penyewaan berdasarkan harga motor dan lama sewa, dan meminta konfirmasi
terakhir dari pengguna sebelum menyimpan data penyewaan ke dalam database.
Selanjutnya, program mengurangi stok motor yang dipilih, membuat catatan penyewaan baru, dan
mengupdate status motor dalam riwayat penyewaan. Akhirnya, program memberikan pesan bahwa data
penyewaan telah berhasil dimuat dan ditambahkan. Jika motor tidak tersedia (stok habis), program
memberikan pesan bahwa stok motor tidak ada. Fungsi ini mencakup berbagai tahapan dalam proses
penyewaan motor dan berinteraksi dengan database untuk merekam transaksi penyewaan pengguna.
fun riwayat(){
val sql= "select history.harga_denda, motor.jenis,
penyewa.tanggal,history.tanggal_balik, history.harga from history join penyewa
on history.id_penyewa = penyewa.id_penyewa join motor on penyewa.id_motor =
motor.id_motor where penyewa.id_user = $idUser AND history.status != 'belum
selesai';"
try {
rs= stmt.executeQuery(sql)
println("===== RIWAYAT SEWA =====")
while (rs.next()){
println("Jenis motor : ${rs.getString("jenis")}\n" +
"Tanggal peminjaman : ${rs.getDate("tanggal")}\n" +
"Tanggal balik : ${rs.getDate("tanggal_balik")}\n" +
"Denda : Rp.${rs.getInt("harga_denda")}\n" +
"Harga awal : Rp.${rs.getInt("harga")}\n" +
"Total : Rp.${rs.getInt("harga") +
rs.getInt("harga_denda")}")
println()
}
Fun riwayat untuk menampilkan riwayat penyewaan motor oleh pengguna. Fungsi ini melakukan
query SQL untuk mengambil data dari tabel history, penyewa, dan motor yang terkait dengan pengguna
tertentu dan memiliki status penyewaan yang tidak sama dengan "belum selesai".
Setelah itu, program mencetak informasi riwayat penyewaan dalam format yang jelas menggunakan loop
while untuk menangani setiap baris hasil query. Informasi yang ditampilkan meliputi jenis motor, tanggal
peminjaman, tanggal pengembalian, denda (jika ada), harga awal penyewaan, dan total biaya penyewaan.
Dengan demikian, fun riwayat ini memberikan pengguna gambaran lengkap tentang semua penyewaan
motor yang telah mereka lakukan yang sudah selesai, termasuk informasi tentang biaya tambahan jika ada
keterlambatan pengembalian. Program ini menggunakan data dari berbagai tabel terkait dalam database
untuk memberikan informasi yang lengkap mengenai riwayat penyewaan pengguna.
fun Keluar(){
println("Apakah Anda Yakin Pada Pilihan Anda(jika iya ketik Y jika tidak
N)")
val ykn =input.nextLine()

println("-------------------------------------------------------------------")
if (ykn=="N"||ykn=="n"){
menu()
}else if(ykn=="Y"||ykn=="y"){
System.exit(0)
}
}
Fun Keluar untuk memberikan opsi kepada pengguna ketika mereka memilih untuk keluar dari
program. Fungsi ini pertama-tama menanyakan kepada pengguna apakah mereka yakin dengan pilihan
keluar, dengan meminta input "Y" (ya) atau "N" (tidak). Setelah menerima input, program mengevaluasi
pilihan pengguna.
Jika pengguna memilih "N" atau "n" (tidak yakin untuk keluar), program memanggil kembali fun menu,
sehingga pengguna dapat kembali ke menu utama dan melanjutkan interaksi dengan program.
Jika pengguna memilih "Y" atau "y" (yakin untuk keluar), program menggunakan System.exit(0) untuk
mengakhiri program secara langsung.
Dengan cara ini, fun Keluar memberikan kontrol kepada pengguna untuk memutuskan apakah mereka
ingin melanjutkan atau mengakhiri program, menambahkan fleksibilitas dan interaktivitas pada
penggunaan program penyewaan motor ini.
fun ulang(){
println("0. Kembali ke halaman awal")
val kembali =input.nextInt()

println("-------------------------------------------------------------------")
if (kembali==0){
menu()
}else{
println()

println("-------------------------------------------------------------------")
println("Terimah kasih Telah Menggunakan Rental Motor Berbayar Kami
(^v^)")

println("-------------------------------------------------------------------")
System.exit(0)
}
}
Fun ulang memberikan opsi kepada pengguna untuk kembali ke halaman awal menu atau keluar
dari program setelah mereka menyelesaikan suatu operasi. Pertama, fungsi mencetak pilihan yang
tersedia, di mana pengguna dapat memasukkan "0" untuk kembali ke halaman awal atau memilih opsi
lain untuk keluar dari program.
Setelah menerima input, program mengevaluasi pilihan pengguna. Jika pengguna memilih "0", program
memanggil kembali fun menu, sehingga pengguna dapat kembali ke menu utama dan melanjutkan
interaksi dengan program.
Jika pengguna memilih opsi lain selain "0", program mencetak pesan terima kasih dan menggunakan
System.exit(0) untuk mengakhiri program secara langsung.
Dengan demikian, fun ulang memberikan fleksibilitas kepada pengguna untuk memilih apakah mereka
ingin melanjutkan atau keluar dari program setelah menyelesaikan suatu operasi.
2.4 Parent (Koneksi.kt)
open class Koneksi(val dbUrl: String, val user: String, val pass: String) {
lateinit var conn: Connection
lateinit var stmt:java.sql.Statement
fun connect() {
try {
Class.forName("com.mysql.cj.jdbc.Driver")
conn = DriverManager.getConnection(dbUrl, user, pass)
stmt = conn.createStatement()
} catch (e: Exception) {
e.printStackTrace()
}
}
}
1. Kelas Terbuka (Open Class): Kelas Koneksi dideklarasikan sebagai kelas terbuka (open class).
kelas ini dapat diwarisi oleh kelas lain (Admin.kt).
2. Properti: Kelas ini memiliki tiga properti, yaitu dbUrl, user, dan pass, yang mewakili URL
database, nama pengguna, dan kata sandi yang digunakan untuk membuat koneksi ke database.
3. Properti lateinit: Kata kunci lateinit digunakan untuk menunda inisialisasi properti hingga suatu
titik dalam eksekusi program. Properti conn dan stmt dideklarasikan dengan lateinit dan
diinisialisasi kemudian saat metode connect() dipanggil.
4. Metode connect(): Metode ini digunakan untuk membuat koneksi ke database. Di dalamnya,
kelas JDBC driver (com.mysql.cj.jdbc.Driver) diinisialisasi, dan koneksi ke database MySQL
dibuat menggunakan DriverManager.getConnection(). Selanjutnya, objek Statement` juga
diinisialisasi untuk menjalankan pernyataan SQL.
5. Penanganan Pengecualian: Dalam metode connect(), terdapat blok penanganan pengecualian
(try-catch). Jika terjadi kesalahan selama proses koneksi, penanganan pengecualian akan
mencetak detail kesalahan melalui e.printStackTrace().
2.5 Child (Admin.kt)

class Admin(dbUrl: String, user: String, pass: String):Koneksi(dbUrl, user,

pass) {

private var loop = true

private var sql = ""
private lateinit var rs: ResultSet
private val scan = Scanner(System.in)

init {
connect()
}
Terdapat class admin yang menerima tiga parameter dbUrl, user dan pass yang semuanya bertipe
data string. Class ini mewarisi kelas lain yang bernama “koneksi”. Variabel loop digunakan untuk
mengontrol suatu loop di dalam kelas. Variabel sql digunakan untuk menyimpan pernyataan SQL yang
akan dieksekusi di dalam kelas ini. Properti rs digunakan untuk menyimpan hasil dari sebuah kueri
database (ResultSet). Objek Scanner dengan nama scan digunakan untuk membaca input dari pengguna
melalui konsol. Memanggil metode connect() yang seharusnya diimplementasikan dalam kelas Koneksi.
Ini menunjukkan bahwa saat objek Admin dibuat, koneksi ke database juga akan dibuka.
fun menu(){
do {
println("\n===== MENU ADMIN =====")
println("1. Info data penyewa")
println("2. Info motor")
println("3. Info Denda")
println("4. Riwayat")
println("0. Exit")
print("\npilih >>> ")
val pilihan = Scanner(System.in).nextLine().toInt()
when(pilihan){
1 -> infoPenyewa()
2 -> infoMotor()
3 -> infoDenda()
4 -> riwayatMotor()
0 -> exitProcess(0)
else -> println("Silahkan pilih menu yang Tersedia....")
}
}while (true)
}
Tujuan dari fun menu() adalah untuk menampilkan menu administratif kepada pengguna,
memproses pilihan mereka, dan melanjutkan proses ini sampai pengguna memilih untuk keluar dari
program. Struktur Loop do-while adalah loop do-while yang akan terus berjalan selama kondisi di dalam
while bernilai true. Disini menampilkan opsi menu yang tersedia seperti info data penyewa, info motor,
info denda, riwayat, dan exit. Selanjutnya menampilkan prompt untuk meminta pengguna memilih menu
dengan tanda panah ganda. Struktur kontrol when digunakan untuk mengevaluasi nilai dari pilihan dan
menjalankan blok kode yang sesuai dengan nilai tersebut. Jika pilihan adalah 1, maka fungsi
infoPenyewa() akan dipanggil. Jika pilihan adalah 2, maka fungsi infoMotor() akan dipanggil. Jika
pilihan adalah 3, maka fungsi infoDenda() akan dipanggil. Jika pilihan adalah 4, maka fungsi
riwayatMotor() akan dipanggil. Jika pilihan adalah 0, maka program akan keluar dari proses dengan
menggunakan exitProcess(0). Jika pilihan tidak cocok dengan opsi yang tersedia, maka pesan kesalahan
akan ditampilkan kepada pengguna.
rivate fun riwayatMotor() {
val sql= "select username, penyewa.id_user,history.harga_denda,
motor.jenis, penyewa.tanggal,history.tanggal_balik, history.harga from history
join penyewa on history.id_penyewa = penyewa.id_penyewa join motor on
penyewa.id_motor = motor.id_motor join users on penyewa.id_user = users.id
where history.status != 'belum selesai';"
try {
rs= stmt.executeQuery(sql)
println("\n===== RIWAYAT =====")
while (rs.next()){
println("Id user : ${rs.getInt("id_user")}\n" +
"Username : ${rs.getString("username")}\n" +
"Jenis motor : ${rs.getString("jenis")}\n" +
"Tanggal peminjaman : ${rs.getDate("tanggal")}\n" +
"Tanggal balik : ${rs.getDate("tanggal_balik")}\n" +
"Denda : Rp.${rs.getInt("harga_denda")}\n" +
"Harga awal : Rp.${rs.getInt("harga")}\n" +
"Total : Rp.${rs.getInt("harga") +
rs.getInt("harga_denda")}")
println()
}
println()
}catch (e:Exception){
e.printStackTrace()
Fungsi riwayatMotor() ini bertujuan untuk mengambil dan menampilkan informasi riwayat
peminjaman motor dari database. Informasi ini mencakup ID user, username, jenis motor, tanggal
peminjaman, tanggal pengembalian, denda, harga awal, dan total biaya. val sql = "select ...":
Mendefinisikan pernyataan SQL untuk mengambil data riwayat dari database. Selanjutnya Menampilkan
informasi riwayat untuk setiap baris hasil. Ini termasuk ID user, username, jenis motor, tanggal
peminjaman, tanggal pengembalian, denda, harga awal, dan total biaya. catch (e: Exception)
{ e.printStackTrace() }: Menangani kemungkinan kesalahan dengan mencetak jejak tumpukan jika terjadi
pengecualian selama eksekusi pernyataan SQL.
private fun infoDenda() {
val sql= "select users.id, users.username, motor.jenis, penyewa.tanggal,
datediff(DATE_ADD(penyewa.tanggal, interval penyewa.lama_sewa day), now()) *
denda as denda from history join penyewa on history.id_penyewa =
penyewa.id_penyewa join motor on penyewa.id_motor = motor.id_motor join users
on penyewa.id_user = users.id where datediff(DATE_ADD(penyewa.tanggal,
interval penyewa.lama_sewa day), now()) > 0 and history.status = 'belum
selesai'"
try {
 rs = stmt.executeQuery(sql)
if (rs.next()){
println("===== INFO DENDA =====")
while (rs.next()){
println("Id : ${rs.getInt("id")}\n" +
"Username : ${rs.getString("username")}\n" +
"Jenis motor : ${rs.getString("jenis")}\n" +
"Tanggal peminjaman : ${rs.getDate("tanggal")}\n" +
"Denda : Rp.${rs.getInt("harga_denda")}\n")
}
}else{
println("Tidak ada Denda")
}
println()
}catch (e:Exception){
e.printStackTrace()
Fun infoDenda() ini digunakan untuk mengambil dan menampilkan informasi denda bagi
pengguna yang memiliki riwayat peminjaman motor belum selesai. Jika ada data denda, informasi
tersebut ditampilkan; jika tidak, pesan "Tidak ada Denda" akan muncul.
private fun infoMotor(){
var loop = true
do {
println("\n===== INFO MOTOR =====")
println("1) List Motor")
println("2) Tambah Motor")
println("3) Update Motor")
println("4) Hapus Motor")
println("0) Back")
print("\npilih >>> ")
val pilihan = Scanner(System.in).nextLine()
when(pilihan){
"1" -> listMotor()
"2" -> tambahMotor()
"3" -> updateMotor()
"4" -> hapusMotor()
"0" -> loop = false
else -> println("Silahkan pilih menu yang Tersedia....")
}
}while (loop)
Fun infoMotor() digunakan untuk menampilkan menu informasi motor kepada pengguna.
Pengguna dapat memilih beberapa opsi, seperti melihat daftar motor, menambah motor baru,
memperbarui informasi motor, menghapus motor, atau kembali ke menu sebelumnya.

private fun hapusMotor() {

println("\n===== HAPUS MOTOR =====\n")
print("Masukkan id user :")
val inp = input.nextLine().toInt()
sql = "select * from motor where id_motor = $inp"
try {
rs = stmt.executeQuery(sql)
if (rs.next()){
print("Apakah anda yakin menghapus motor ini? [yes/no] ")
 var bro = scan.nextLine()
when(bro){
"yes" ->{
sql = "delete from motor where id_motor = $inp"
stmt.execute(sql)
println("Mootr berhasil dihapus")
}
"no" -> {
println("Gagal menghapus motor")
}
else -> {
println("Pilihan tidak valid...")
}
}
}else{
println("Tidak ada user dengan id $inp")
}
}catch (e:java.lang.Exception){
e.printStackTrace()
Fun hapusMotor() menghapus informasi motor dari database berdasarkan ID pengguna.
Sebelum menghapus, program memberikan konfirmasi kepada pengguna dan memberikan pesan yang
sesuai. meminta pengguna untuk mengidentifikasi ID motor yang ingin dihapus. Proses Penghapusan:
Jika pengguna menjawab "yes", pernyataan SQL delete from motor where id_motor = $inp dieksekusi
untuk menghapus motor dari database. Jika pengguna menjawab "no", program memberikan pesan bahwa
penghapusan dibatalkan, dan jika jawaban pengguna tidak valid, program memberikan pesan bahwa
pilihan tidak valid.

private fun updateMotor() {

println("\n===== EDIT MOTOR =====\n")
print("Masukkan id motor :")
val inp = input.nextLine().toInt()
sql = "select * from motor where id_motor = $inp"
try {
rs = stmt.executeQuery(sql)
if (rs.next()){
print("Jenis : ")
var jenis = scan.nextLine()
print("Keterangan : ")
var ket = scan.nextLine()
print("Status : ")
var status = scan.nextLine()
print("Harga : ")
var harga = scan.nextLine().toInt()
print("Denda : ")
var denda = scan.nextLine().toInt()
print("Stok : ")
var stok = scan.nextLine().toInt()

println("Apakah anda ingin menambahkan motor dengan:")

println("Jenis : $jenis\n" +
"Keterangan : $ket\n" +
"Status : $status\n" +
 "Harga : $harga\n" +
"Denda : $denda\n" +
"Stok : $stok\n")
print("[yes/no] ")
var validasi = scan.nextLine()
when(validasi){
"yes" -> {
sql = "update motor values jenis ='$jenis', ket = '$ket',
status = '$status',harga = $harga,stok = $stok,denda = $denda)"
try {
stmt.execute(sql)
println("Data berhasil di tambahkan")
}catch (e:java.lang.Exception){
e.printStackTrace()
}

}
"no" -> println("Gagal menambahkan")
else -> println("Silahkan pilih menu yang Tersedia....")
}
}else{
println("Tidak ada user dengan id $inp")
}
}catch (e:java.lang.Exception){
e.printStackTrace()
Fun updateMotor() ini, pengguna dapat mengedit informasi motor di database. Pengguna
diminta untuk memasukkan ID motor yang ingin diubah di sini. Input.nextLine().val inp.toInt():
Membaca input pengguna dalam bentuk string, mengonversinya ke tipe data Int, dan kemudian
menyimpannya dalam variabel inp. Struktur kontrol ketika digunakan untuk menilai respons pengguna.
Program melakukan pernyataan update SQL untuk mengedit informasi motor jika pengguna menjawab
"yes", jika pengguna menjawab "no", program memberikan pesan bahwa pengeditan dibatalkan, dan jika
jawaban pengguna tidak valid, program memberikan pesan bahwa pilihan tidak valid.

private fun tambahMotor() {

println("\n===== TAMBAH MOTOR =====")
print("Id : ")
var idMotor = scan.nextLine().toInt()
print("Jenis : ")
var jenis = scan.nextLine()
print("Keterangan : ")
var ket = scan.nextLine()
print("Status : ")
var status = scan.nextLine()
print("Harga : ")
var harga = scan.nextLine().toInt()
print("Denda : ")
var denda = scan.nextLine().toInt()
print("Stok : ")
var stok = scan.nextLine().toInt()

println("Apakah anda ingin menambahkan motor dengan:")

println("Id : $idMotor\n" +
 "Jenis : $jenis\n" +
"Keterangan : $ket\n" +
"Status : $status\n" +
"Harga : $harga\n" +
"Denda : $denda\n" +
"Stok : $stok\n")
print("[yes/no] ")
var validasi = scan.nextLine()
when(validasi){
"yes" -> {
sql = "insert into motor values
($idMotor,'$jenis','$ket','$status',$harga,$stok,$denda)"
try {
stmt.execute(sql)
println("Data berhasil di tambahkan")
}catch (e:java.lang.Exception){
e.printStackTrace()
}

}
"no" -> println("Gagal menambahkan")
else -> println("Silahkan pilih menu yang Tersedia....")
}
}
Fun tambahMotor() memungkinkan pengguna untuk menambahkan informasi motor baru ke
dalam database. Pengguna diminta untuk memasukkan informasi baru seperti ID, jenis, keterangan,
status, harga, denda, dan stok motor.

private fun listMotor() {

println("\n===== LIST MOTOR =====")
sql = "select * from motor"
try {
rs = stmt.executeQuery(sql)
while (rs.next()){
println("Id : ${rs.getInt("id_motor")}\n" +
"Jenis : ${rs.getString("jenis")}\n" +
"Keterangan : ${rs.getString("ket")}\n" +
"Status : ${rs.getString("status")}\n" +
"Harga/hari : ${rs.getInt("harga")}\n" +
"Denda/hari : ${rs.getInt("denda")}\n" +
"Stok : ${rs.getInt("stok")}")
println()
}
}catch (e:java.lang.Exception){
e.printStackTrace()
}
Fun listMotor() menampilkan daftar motor yang ada dalam database, serta detail lengkap tentang
setiap motor. Fungsi ini juga menampilkan informasi untuk setiap baris hasil, seperti ID motor, jenis,
keterangan, status, harga, denda, dan stok.

private fun infoPenyewa() {

do {
 println("\n===== INFO PENYEWA =====")
println("1) Edit")
println("2) Hapus")
println("3) List penyewa")
println("0) Back")
print("\npilih >>> ")
val pilihan = Scanner(System.in).nextLine()
when(pilihan){
"1" -> editPenyewa()
"2" -> hapusPenyewa()
"3" -> listPenyewa()
"0" -> loop = false
else -> println("Silahkan pilih menu yang Tersedia....")
}
}while (loop)
Fun infoPenyewa() memberikan opsi kepada pengguna untuk berinteraksi dengan informasi
penyewa, seperti mengedit, menghapus, atau melihat daftar penyewa. Pengguna dapat terus memilih opsi
hingga mereka memilih untuk kembali ke menu sebelumnya.

private fun listPenyewa() {

println("\n===== LIST PENYEWA =====")
sql = "SELECT * FROM users where role = 0"
try {
rs = stmt.executeQuery(sql)
while (rs.next()){
println("Id : ${rs.getInt("id")}\n" +
"Username : ${rs.getString("username")}\n" +
"Nama : ${rs.getString("nama")}\n" +
"Tanggal Lahir : ${rs.getDate("tgl_lahir")}\n" +
"Jenis Kelamin : ${rs.getString("jenis_kelamin")}\n" +
"Alamat : ${rs.getString("alamat")}")
println()
}
}catch (e:java.lang.Exception){
e.printStackTrace()
Fun listPenyewa() menampilkan daftar penyewa dari database dengan detail lengkap tentang
setiap penyewa. Menampilkan informasi untuk setiap baris hasil, termasuk ID, username, nama, tanggal
lahir, jenis kelamin, dan alamat penyewa.
private fun hapusPenyewa() {
println("\n===== HAPUS PENYEWA =====\n")
print("Masukkan id user :")
val inp = input.nextLine().toInt()
sql = "select * from users where id = $inp"
try {
rs = stmt.executeQuery(sql)
if (rs.next()){
print("Apakah anda yakin menghapus user ini? [yes/no] ")
var bro = scan.nextLine()
when(bro){
"yes" ->{
sql = "delete from users where id = $inp"
 stmt.execute(sql)
println("user berhasil dihapus")
}
"no" -> {
println("Gagal menghapus user")
}
else -> {
println("Pilihan tidak valid...")
}
}
}else{
println("Tidak ada user dengan id $inp")
}
}catch (e:java.lang.Exception){
e.printStackTrace()
}
Fun hapusPenyewa() menghapus informasi penyewa dari database menggunakan ID pengguna.
Program mengkonfirmasi pengguna sebelum melakukan penghapusan dan mengatasi berbagai situasi
dengan memberikan pesan yang sesuai.

private fun editPenyewa() {

println("\n===== Edit PENYEWA =====\n")
print("Masukkan id user :")
val inp = input.nextLine().toInt()
sql = "select * from users where id = $inp"
try {
rs = stmt.executeQuery(sql)
if (rs.next()){
print("Username : ")
var username = scan.nextLine()
print("nama : ")
var nama = scan.nextLine()
print("Tanggal Lahir : ")
var tgl = scan.nextLine()
print("Jenis Kelamin : ")
var jk = scan.nextLine()
print("Alamat : ")
var alamat = scan.nextLine()
print("Password : ")
var password = scan.nextLine()

println("Apakah anda ingin mengupdate user id $inp dengan:")

println("Nama : $nama\n" +
"Username : $username\n" +
"Tanggal Lahir : $tgl\n" +
"Jenis Kelamin : $jk\n" +
"Alamat : $alamat\n" +
"Password : $password\n")
print("[yes/no]")
var validasi = scan.nextLine()
when(validasi){
"yes" -> {
sql = "update users set username = '$username', nama =
'$nama', jenis_kelamin ='$jk',alamat = '$alamat',tgl_lahir = $tgl,password =
'$password' where id = $inp"
stmt.execute(sql)
}
"no" -> println("Anda tidak merubah")
else -> println("Silahkan pilih menu yang Tersedia....")
}
}else{
println("Tidak ada user dengan id $inp")
}
}catch (e:java.lang.Exception){
e.printStackTrace()
Fun editPenyewa() memungkinkan mengubah informasi penyewa di database yang didasarkan
pada ID pengguna. Sebelum melakukan update, program memberikan konfirmasi kepada pengguna
dengan memberikan pesan yang sesuai. Selama proses update, jika pengguna menjawab "yes", program
melakukan pernyataan update SQL untuk mengedit informasi pengguna; jika pengguna menjawab "no",
program memberikan pesan bahwa pengeditan dibatalkan; dan jika jawaban pengguna tidak valid,
program memberikan pesan bahwa pilihan tidak valid.

2.6 Tambahan dari bapak

1. Mencari data penyewa sesuai tanggal yang diinput

private fun listPenyewa() {

println("\n===== LIST PENYEWA =====")

var rentalDate: String? = null

print("Enter rental date (yyyy-MM-dd): ")

rentalDate = readLine()

val baseSql = "SELECT * FROM users WHERE role = 0"

val sql = if (rentalDate != null) {
"$baseSql AND id IN (SELECT id_user FROM penyewa WHERE tanggal =
'$rentalDate')"
} else {
baseSql
}

try {
val rs = stmt.executeQuery(sql)

while (rs.next()) {
println("Id : ${rs.getInt("id")}\n" +
"Username : ${rs.getString("username")}\n" +
"Nama : ${rs.getString("nama")}\n" +
"Tanggal Lahir : ${rs.getDate("tgl_lahir")}\n" +
"Jenis Kelamin : ${rs.getString("jenis_kelamin")}\n" +
"Alamat : ${rs.getString("alamat")}")
println()
}
} catch (e: Exception) {
 e.printStackTrace()
}
}

Fungsi ini bertujuan untuk menampilkan daftar penyewa dengan beberapa informasi terkait,
seperti ID, username, nama, tanggal lahir, jenis kelamin, dan alamat. Fungsi ini mencetak judul "=====
LIST PENYEWA =====" untuk memberikan pemisah visual sebelum menampilkan daftar penyewa.
Selanjutnya, variabel rentalDate dideklarasikan dan diminta nilai dari pengguna dengan menggunakan
readLine() untuk tanggal sewa. Dibuat sebuah string SQL dasar (baseSql) yang mengambil semua
pengguna dengan peran (role) 0, yang menunjukkan bahwa mereka adalah penyewa. Selanjutnya, variabel
sql dibuat dengan menyesuaikan string dasar tergantung pada apakah tanggal sewa (rentalDate) telah
diinput oleh pengguna atau tidak. Jika tanggal sewa diinput, SQL akan disesuaikan untuk hanya memilih
penyewa yang telah menyewa pada tanggal tersebut.
Kemudian, dilakukan eksekusi query SQL dengan menggunakan objek stmt (yang telah dideklarasikan).
Hasil query disimpan dalam objek rs, dan fungsi melakukan iterasi melalui setiap baris hasil (rs.next())
untuk mencetak informasi penyewa seperti ID, username, nama, tanggal lahir, jenis kelamin, dan alamat.
Terakhir, terdapat penanganan exception (catch) yang mencetak trace jika terjadi kesalahan selama
eksekusi query.

2. Menampilkan data motor yang best seller (sering disewa)

private fun listMotor() {

println("\n===== LIST MOTOR =====")
sql = "select * from motor"
try {
rs = stmt.executeQuery(sql)
while (rs.next()){
println("Id : ${rs.getInt("id_motor")}\n" +
"Jenis : ${rs.getString("jenis")}\n" +
"Keterangan : ${rs.getString("ket")}\n" +
"Status : ${rs.getString("status")}\n" +
"Harga/hari : ${rs.getInt("harga")}\n" +
"Denda/hari : ${rs.getInt("denda")}\n" +
"Stok : ${rs.getInt("stok")}")
println()
}
println("Motor yang Sering Disewa:")

println("-------------------------------------------------------------------")

val motorSeringDisewa = getMotorSeringDisewa()

if (motorSeringDisewa != null) {
println("ID Motor: ${motorSeringDisewa.id}\n" +
"Jenis : ${motorSeringDisewa.jenis}\n" +
"Harga/hari : ${motorSeringDisewa.harga}\n" +
 "Ketersediaan : ${motorSeringDisewa.stok} unit\n" +
"Jumlah Penyewaan : ${motorSeringDisewa.tersewa} kali")
} else {
println("Tidak ada motor yang tersedia untuk disewa.")
}

infoMotor()
} catch (e: Exception) {
e.printStackTrace()
}
}
data class Motor(
val id: Int,
val jenis: String,
val harga: Int,
val stok: Int,
val tersewa: Int
)

fun getMotorSeringDisewa(): Motor? {

val sql = "SELECT * FROM motor ORDER BY tersewa DESC LIMIT 1"

try {
val resultSet = stmt.executeQuery(sql)

if (resultSet.next()) {
return Motor(
resultSet.getInt("id_motor"),
resultSet.getString("jenis"),
resultSet.getInt("harga"),
resultSet.getInt("stok"),
resultSet.getInt("tersewa")
)
}
} catch (e: Exception) {
e.printStackTrace()
}

return null
}
Fun listMotor() bertujuan untuk menampilkan informasi mengenai motor-motor yang tersedia
untuk disewa. Pertama-tama, fungsi ini mengeksekusi query SQL untuk mengambil semua data dari tabel
motor, termasuk ID motor, jenis, keterangan, status, harga per hari, denda per hari, dan stok. Informasi
tersebut kemudian dicetak dalam bentuk paragraf untuk setiap motor. Selanjutnya, fungsi ini mencoba
mendapatkan informasi mengenai motor yang sering disewa melalui pemanggilan fun
getMotorSeringDisewa(). Jika motor yang sering disewa ditemukan, informasinya seperti ID, jenis,
harga per hari, ketersediaan stok, dan jumlah penyewaan dicetak. Jika tidak ada motor yang sering
disewa, pesan yang menyatakan bahwa tidak ada motor yang tersedia untuk disewa akan dicetak. Selain
itu, terdapat definisi data class Motor yang digunakan untuk menyimpan informasi spesifik mengenai
motor. Fun getMotorSeringDisewa() berperan dalam mengambil data motor yang sering disewa dari
database melalui query khusus, dan jika data ditemukan, objek Motor dibentuk untuk kemudian
dikembalikan.
3. Rekapan pemasukkan sesuai tanggal yang diinput

fun pemasukkan() {
println("\n===== PEMASUKKAN HARI INI =====")
print("Masukkan tanggal balik (yyyy-MM-dd): ")
val tanggalBalik = scan.nextLine()

val sql = "SELECT penyewa.id_user, users.username, motor.jenis,

penyewa.tanggal, history.tanggal_balik, history.harga, history.harga_denda " +
"FROM history " +
"JOIN penyewa ON history.id_penyewa = penyewa.id_penyewa " +
"JOIN motor ON penyewa.id_motor = motor.id_motor " +
"JOIN users ON penyewa.id_user = users.id " +
"WHERE history.tanggal_balik = '$tanggalBalik' AND
history.status != 'belum lunas'"

try {
rs = stmt.executeQuery(sql)
if (rs.next()) {
println("\n===== DATA PEMASUKAN =====")
var totalPemasukkan = 0
while (rs.next()) {
val harga = rs.getInt("harga")
val denda = rs.getInt("harga_denda")
val total = harga + denda

println("Id user : ${rs.getInt("id_user")}\n" +

"Username : ${rs.getString("username")}\n" +
"Jenis motor : ${rs.getString("jenis")}\n" +
"Tanggal peminjaman : ${rs.getDate("tanggal")}\n" +
"Tanggal balik : ${rs.getDate("tanggal_balik")}\n" +
"Harga : Rp.$harga\n" +
"Denda : Rp.$denda\n" +
"Total : Rp.$total\n")

totalPemasukkan += total
}

println("Rekapan Pemasukkan $tanggalBalik: Rp.$totalPemasukkan")

} else {
println("Tidak ada data pemasukan pada tanggal tersebut.")
}
println()
} catch (e: Exception) {
e.printStackTrace()
}
}
Fun pemasukkan() untuk menampilkan informasi pemasukkan pada suatu tanggal tertentu
berdasarkan data transaksi penyewaan motor yang telah selesai. Pertama, pengguna diminta untuk
memasukkan tanggal balik melalui console. Selanjutnya, sebuah query SQL dibuat untuk mengambil data
terkait dari tabel history yang berisi informasi transaksi penyewaan motor, termasuk ID pengguna,
username, jenis motor, tanggal peminjaman, tanggal balik, harga sewa, dan harga denda. Data tersebut
diasosiasikan melalui JOIN dengan tabel-tabel terkait seperti penyewa, motor, dan users.
Kemudian, query tersebut dieksekusi, dan hasilnya disimpan dalam objek rs. Jika ada setidaknya satu
hasil, program akan memproses dan mencetak informasi transaksi untuk setiap entri, seperti ID pengguna,
username, jenis motor, tanggal peminjaman, tanggal balik, harga sewa, harga denda, dan total. Selain itu,
dilakukan penjumlahan total pemasukkan dari transaksi tersebut. Rekapan keseluruhan termasuk total
pemasukkan untuk tanggal yang dimasukkan kemudian dicetak.
Jika tidak ada hasil dari query, program mencetak pesan bahwa tidak ada data pemasukan pada tanggal
tersebut. Keseluruhan proses dilakukan di dalam blok try-catch untuk menangani kemungkinan kesalahan
eksekusi query atau akses data.
Fungsi ini memberikan pemahaman tentang cara mengakses dan memproses data transaksi penyewaan
motor untuk menghasilkan informasi pemasukkan pada suatu tanggal tertentu.
 BAB III
PENUTUP

3.1 KESIMPULAN
Pembuatan sistem rental sepeda motor berbayar melibatkan pengembangan perangkat lunak yang
dapat mengintegrasikan berbagai fungsi, mulai dari manajemen pemesanan, pembayaran. Dengan adanya
sistem ini, diharapkan dapat meningkatkan kenyamanan dan fleksibilitas pengguna dalam menggunakan
sepeda motor sebagai modal transportasi. Selain itu, penyedia layanan juga diuntungkan dengan efisiensi
operasional, pemantauan yang lebih baik, dan potensi peningkatan pendapatan.
Penting untuk memastikan keamanan data pribadi pengguna dan menjaga keandalan sistem agar
dapat memberikan pengalaman pengguna yang baik. Dengan demikian, pengembangan sistem ini perlu
dilakukan dengan mempertimbangkan aspek keamanan dan keandalan guna menciptakan solusi yang
berkelanjutan dan dapat diandalkan dalam jangka panjang.