Note

Disusun oleh :
Axl Beatrix Putra – 10220076
Muhammad Fillah Fadillah – 10220040
Gadis Tapana Bela – 10220072
Elisabet Rifani Tato – 10220057
Fahrezi Kurnia Dani – 10220095

PROGRAM STUDI REKAYASA PERANGKAT LUNAK

FAKULTAS TEKNIK DAN INFORMATIKA
UNIVERSITAS BINA SARANA INFORMATIKA
MARGONDA
2024
 Kata Pengantar
Puji dan syukur kami panjatkan ke hadirat Tuhan Yang Maha Esa atas rahmat
dan karunia-Nya sehingga kami dapat menyelesaikan pengembangan aplikasi mobile
CRUD berbasis REST API dengan tema Catatan ini. Aplikasi ini dirancang untuk
mempermudah pengguna dalam mengelola catatan pribadi secara efektif dan efisien
melalui perangkat mobile.
Aplikasi ini memiliki fitur utama Create, Read, Update, dan Delete (CRUD),
yang memungkinkan pengguna untuk: menambahkan catatan baru, membaca daftar
catatan yang telah dibuat, mengedit catatan yang sudah ada, dan menghapus catatan
yang tidak diperlukan.
Proyek ini menggunakan arsitektur REST API untuk mendukung komunikasi
antara aplikasi mobile dan server. Dengan demikian, data dapat disimpan secara aman
dan diakses kapan saja melalui internet. Dalam proses pengembangan, kami telah
memanfaatkan berbagai teknologi terkini, seperti Flutter untuk pengembangan
antarmuka pengguna dan integrasi dengan REST API untuk pengelolaan data. Kami
berharap aplikasi ini dapat menjadi solusi praktis bagi pengguna dalam mengatur
catatan sehari-hari dengan lebih terorganisir.

Kami menyadari bahwa masih terdapat banyak hal yang dapat dikembangkan
dari aplikasi ini. Oleh karena itu, kami terbuka terhadap kritik dan saran yang
membangun untuk perbaikan di masa mendatang. Akhir kata, kami mengucapkan
terima kasih kepada semua pihak yang telah membantu dalam pengembangan
aplikasi ini, baik secara langsung maupun tidak langsung. Semoga aplikasi ini
bermanfaat bagi semua pengguna.

Margonda, Desember 2024

Tim Pengembang Kelompok 6

Table of Contents
Kata Pengantar.........................................................................................................................1
BAB I.........................................................................................................................................1
BAB II........................................................................................................................................1
BAB III.......................................................................................................................................1
 BAB I

1.1 Latar Belakang Proyek

Dalam era digital saat ini, kebutuhan akan kemudahan dan efisiensi dalam
mengelola informasi semakin meningkat. Baik individu maupun organisasi
dituntut untuk mencatat, menyimpan, dan mengakses informasi dengan cepat dan
mudah. Salah satu solusi yang menjadi populer adalah aplikasi notes, yang
dirancang untuk membantu pengguna mencatat berbagai hal, mulai dari ide,
daftar tugas, hingga dokumen penting.

Aplikasi notes tidak hanya menggantikan peran buku catatan konvensional

tetapi juga memberikan berbagai keunggulan tambahan, seperti kemampuan
untuk menyimpan catatan secara digital, berbagi dengan orang lain, dan
mengintegrasikan catatan dengan perangkat lain. Dengan dukungan teknologi
cloud, aplikasi notes memungkinkan aksesibilitas di berbagai perangkat, yang
menjadi kebutuhan utama di tengah mobilitas tinggi masyarakat modern.

Makalah ini bertujuan untuk menggali lebih dalam mengenai peran aplikasi
notes dalam membantu produktivitas, memahami keunggulan dan kekurangannya,
serta mengeksplorasi bagaimana aplikasi ini dapat terus berkembang sesuai
dengan kebutuhan masyarakat.

1.2 Tujuan Utama Proyek

1.2.1 Mempermudah Pengelolaan Informasi
Aplikasi notes dirancang untuk membantu pengguna mencatat, menyimpan,
dan mengatur informasi penting secara efisien, baik itu ide, daftar tugas,
catatan kuliah, atau dokumen kerja.
1.2.2 Meningkatkan Produktivitas
Dengan menyediakan fitur seperti pencarian cepat, pengorganisasian berbasis
folder/tag, dan pengingat (reminder), aplikasi notes bertujuan untuk
membantu pengguna mengelola waktu dan tugas dengan lebih baik, sehingga
produktivitas meningkat.
1.2.3 Aksesibilitas dan Mobilitas
Aplikasi ini memungkinkan pengguna untuk mengakses catatan mereka kapan
saja dan di mana saja melalui sinkronisasi antar perangkat menggunakan
teknologi cloud.
 BAB II

A. restful_api_php>api>post>
1. Api_service.dart
Code :
import 'dart:convert';
import 'package:http/[Link]' as http;

class ApiService {
static const String baseUrl =
"[Link]

static Future<Map<String, dynamic>> registerUser(

String name, String email, String password) async {
try {
final response = await [Link](
[Link]("$baseUrl/api/user/[Link]"),
body: jsonEncode({"name": name, "email": email,
"password": password}),
headers: {"Content-Type": "application/json"},
);

// Debugging untuk response HTTP

print("Response status: ${[Link]}");
print("Response body: ${[Link]}");

// Pastikan respons JSON valid

if ([Link] == 200) {
return jsonDecode([Link]);
} else {
return {"message": "Failed to connect to server"};
}
} catch (e) {
print("Error: $e");
return {"message": "An error occurred"};
}
}

static Future<Map<String, dynamic>> loginUser(

String email, String password) async {
final response = await [Link](
[Link]("$baseUrl/api/user/[Link]"),
body: jsonEncode({"email": email, "password": password}),
headers: {"Content-Type": "application/json"},
);

return jsonDecode([Link]);
}
 static Future<List<dynamic>> getPosts() async {
final response = await
[Link]([Link]("$baseUrl/api/post/[Link]"));
return jsonDecode([Link]);
}

//create post
static Future<Map<String, dynamic>> addPost(
int userId, String title, String content) async {
final response = await [Link](
[Link]("$baseUrl/api/post/[Link]"),
body: jsonEncode({
"user_id": userId,
"title": title,
"content": content,
}),
headers: {"Content-Type": "application/json"},
);

return jsonDecode([Link]);
}

// Update post
static Future<Map<String, dynamic>> updatePost(
int id, int userId, String title, String content) async {
final response = await [Link](
[Link]("$baseUrl/api/post/[Link]"),
body: jsonEncode(
{"id": id, "user_id": userId, "title": title, "content":
content}),
headers: {"Content-Type": "application/json"},
);

return jsonDecode([Link]);
}

// Delete post
static Future<Map<String, dynamic>> deletePost(int id, int
userId) async {
final response = await [Link](
[Link]("$baseUrl/api/post/[Link]"),
body: jsonEncode({"id": id, "user_id": userId}),
headers: {"Content-Type": "application/json"},
);

return jsonDecode([Link]);
}
}

Kode ini merupakan implementasi sebuah service API dalam bahasa Dart,
yang dirancang untuk berkomunikasi dengan server berbasis RESTful API
menggunakan paket http. Kode ini mencakup berbagai fungsi untuk CRUD
(Create, Read, Update, Delete) data pengguna dan postingan di server.
Deskripsi Fungsi
- Konstanta baseUrl
Berisi URL dasar dari API. URL ini digunakan sebagai titik awal untuk semua
permintaan ke server.
static const String baseUrl =
"[Link]
- registerUser
Digunakan untuk mendaftarkan pengguna baru ke sistem. Data pengguna
dikirim ke endpoint api/user/[Link] dalam format JSON menggunakan
metode POST.
 Parameter:
■ name (String)
■ email (String)
■ password (String)
 Pengembalian: Map berisi respons server (berupa pesan status).
- loginUser
Berfungsi untuk autentikasi pengguna dengan mengirimkan email dan
password ke endpoint api/user/[Link].
 Parameter:
■ email (String)
■ password (String)
 Pengembalian: Map berisi respons server (token atau status login).
- getPosts
Mendapatkan daftar semua postingan dari server menggunakan metode GET
ke endpoint api/post/[Link].
 Pengembalian: List berisi data postingan.
- addPost
 Digunakan untuk menambahkan postingan baru ke server. Data yang dikirim
berupa ID pengguna, judul, dan konten postingan.
 Parameter:
■ userId (int)
■ title (String)
■ content (String)
 Pengembalian: Map berisi status operasi.
- updatePost
Memperbarui data postingan yang sudah ada berdasarkan ID postingan.
 Parameter:
■ id (int): ID postingan yang akan diperbarui.
■ userId (int): ID pengguna.
■ title (String): Judul baru.
■ content (String): Konten baru.
 Pengembalian: Map berisi status operasi.
- deletePost
Menghapus postingan berdasarkan ID.
 Parameter:
■ id (int): ID postingan.
■ userId (int): ID pengguna yang memiliki postingan.
 Pengembalian: Map berisi status operasi.
2. home_screen.dart
Code :
import 'package:flutter/[Link]';
import '../api/api_service.dart';

class HomeScreen extends StatefulWidget {

final int userId;

HomeScreen({required [Link]});

@override
_HomeScreenState createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {

final TextEditingController titleController =
TextEditingController();
final TextEditingController contentController =
TextEditingController();
late Future<List> postsFuture;

@override
void initState() {
[Link]();
postsFuture = [Link]();
}

void addPost() async {

if ([Link] &&
[Link]) {
final response = await [Link](
[Link],
[Link],
[Link],
);

[Link](context)
.showSnackBar(SnackBar(content:
Text(response['message'])));

if (response['message'] == "Post added successfully") {

setState(() {
postsFuture = [Link](); // Refresh the
posts
});
[Link]();
 [Link]();
}
} else {
[Link](context).showSnackBar(
SnackBar(content: Text("Title and content cannot be
empty")));
}
}

void editPost(BuildContext context, Map post) async {

final TextEditingController editTitleController =
TextEditingController(text: post['title']);
final TextEditingController editContentController =
TextEditingController(text: post['content']);

showDialog(
context: context,
builder: (context) {
return AlertDialog(
title: Text("Edit Post"),
content: Column(
mainAxisSize: [Link],
children: [
TextField(
controller: editTitleController,
decoration: InputDecoration(labelText: "Title"),
),
TextField(
controller: editContentController,
decoration: InputDecoration(labelText: "Content"),
maxLines: 3,
),
],
),
actions: [
ElevatedButton(
onPressed: () async {
final response = await [Link](
post['id'],
[Link],
[Link],
[Link],
);
[Link](context)
.showSnackBar(SnackBar(content:
Text(response['message'])));
 if (response['message'] == "Post updated
successfully") {
setState(() {
postsFuture = [Link]();
});
}
[Link](context);
},
child: Text("Save"),
),
],
);
},
);
}

void deletePost(int postId) async {

final response = await [Link](postId,
[Link]);

[Link](context)
.showSnackBar(SnackBar(content:
Text(response['message'])));

if (response['message'] == "Post deleted successfully") {

setState(() {
postsFuture = [Link](); // Refresh the posts
});
}
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: Text("Home")),
body: Column(
children: [
Padding(
padding: const [Link](16.0),
child: Column(
children: [
TextField(
controller: titleController,
decoration: InputDecoration(labelText: "Title"),
),
TextField(
controller: contentController,
 decoration: InputDecoration(labelText:
"Content"),
maxLines: 3,
),
SizedBox(height: 10),
ElevatedButton(
onPressed: addPost,
child: Text("Add Post"),
),
],
),
),
Expanded(
child: FutureBuilder(
future: postsFuture,
builder: (context, snapshot) {
if ([Link] ==
[Link]) {
return Center(child:
CircularProgressIndicator());
} else if ([Link]) {
return Center(child: Text("Error: $
{[Link]}"));
} else {
final posts = [Link] as List;
return [Link](
itemCount: [Link],
itemBuilder: (context, index) {
final post = posts[index];
return Card(
margin:
[Link](horizontal: 16,
vertical: 8),
child: ListTile(
title: Text(post['title']),
subtitle: Text(post['content']),
trailing: post['user_id'] ==
[Link]
? Row(
mainAxisSize: [Link],
children: [
IconButton(
icon: Icon([Link]),
onPressed: () =>
editPost(context, post),
// Edit post
),
 IconButton(
icon: Icon([Link]),
onPressed: () =>
deletePost(post['id']),
// Delete post
),
],
)
: null,
),
);
},
);
}
},
),
),
],
),
);
}
}
File home_service.dart adalah bagian penting dalam aplikasi Flutter yang
bertanggung jawab untuk komunikasi dengan API server. File ini menangani
pengambilan, pengiriman, pembaruan, dan penghapusan data dari server. Berikut
fungsi utamanya:
- Mengambil Data (GET): Mengambil data dari API, seperti daftar posts, dan
mengembalikannya dalam format JSON.
Future<List> getPosts() async { /*...*/ }
- Menambahkan Data (POST): Mengirim data baru ke server.
Future<Map> addPost(int userId, String title, String content) async { /*...*/ }
- Memperbarui Data (PUT/PATCH): Memperbarui data yang sudah ada
berdasarkan ID.
Future<Map> updatePost(int postId, int userId, String title, String content)
async { /*...*/ }
- Menghapus Data (DELETE): Menghapus data berdasarkan ID.
Future<Map> deletePost(int postId, int userId) async { /*...*/ }
 - Error Handling: Menangani kesalahan seperti koneksi gagal atau respons
server tidak valid.
File ini mendukung modularitas dengan memisahkan logika API dari
antarmuka pengguna di home_screen.dart, sehingga memudahkan
pemeliharaan, penggunaan ulang, dan pengujian aplikasi.

3. login_service.dart
import 'package:flutter/[Link]';
import '../api/api_service.dart';
import 'home_screen.dart';
import 'register_screen.dart';

class LoginScreen extends StatelessWidget {

final TextEditingController emailController =
TextEditingController();
final TextEditingController passwordController =
TextEditingController();

void login(BuildContext context) async {

final response = await [Link](
[Link],
[Link],
);

if ([Link]("id")) {
[Link](
context,
MaterialPageRoute(
builder: (context) => HomeScreen(userId:
response['id'])),
);
} else {
[Link](context)
.showSnackBar(SnackBar(content:
Text(response['message'])));
}
}

@override
Widget build(BuildContext context) {
 return Scaffold(
appBar: AppBar(title: Text("Login")),
body: Padding(
padding: const [Link](16.0),
child: Column(
children: [
TextField(
controller: emailController,
decoration: InputDecoration(labelText: "Email"),
),
TextField(
controller: passwordController,
decoration: InputDecoration(labelText: "Password"),
obscureText: true,
),
SizedBox(height: 16),
ElevatedButton(
onPressed: () => login(context),
child: Text("Login"),
),
TextButton(
onPressed: () {
[Link](
context,
MaterialPageRoute(builder: (context) =>
RegisterScreen()),
);
},
child: Text("Don't have an account? Register
here."),
),
],
),
),
);
File login_service.dart bertugas menangani proses autentikasi dengan API server.
Fungsinya meliputi:
- Login (POST): Mengirim email dan password ke server.
Future<Map<String, dynamic>> loginUser(String email, String password)
async {
final response = await [Link](
[Link]('[Link]
body: {'email': email, 'password': password},
 );
if ([Link] == 200) {
return [Link]([Link]);
} else {
hrow Exception('Failed to login'); }
}
- Validasi Respons: Mengembalikan data pengguna jika sukses, atau pesan error
jika gagal.
- Error Handling: Menangani masalah koneksi atau kesalahan server.
File ini mendukung login_screen.dart dengan menyediakan logika login,
membuat kode lebih modular, mudah dipelihara, dan dapat digunakan kembali.

4. register_service.dart
import 'package:flutter/[Link]';
import '../api/api_service.dart';

class RegisterScreen extends StatefulWidget {

@override
_RegisterScreenState createState() => _RegisterScreenState();
}

class _RegisterScreenState extends State<RegisterScreen> {

final TextEditingController nameController =
TextEditingController();
final TextEditingController emailController =
TextEditingController();
final TextEditingController passwordController =
TextEditingController();

bool isLoading = false; // State untuk indikator loading

void register(BuildContext context) async {

setState(() {
isLoading = true;
});

try {
final response = await [Link](
[Link](),
[Link](),
 [Link](),
);

// Tampilkan pesan dari server

[Link](context).showSnackBar(
SnackBar(content: Text(response['message'] ?? "Unknown
error")),
);

// Navigasi jika berhasil

if (response['message'] == "User registered successfully") {
[Link](context);
}
} catch (e) {
// Tampilkan pesan error
[Link](context).showSnackBar(
SnackBar(content: Text("Registration failed: $e")),
);
} finally {
setState(() {
isLoading = false; // Hentikan loading
});
}
}

@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: Text("Register")),
body: Padding(
padding: const [Link](16.0),
child: Column(
children: [
TextField(
controller: nameController,
decoration: InputDecoration(labelText: "Name"),
),
TextField(
controller: emailController,
decoration: InputDecoration(labelText: "Email"),
),
TextField(
controller: passwordController,
decoration: InputDecoration(labelText: "Password"),
obscureText: true,
),
SizedBox(height: 16),
 isLoading
? CircularProgressIndicator() // Tampilkan loading
saat proses
: ElevatedButton(
onPressed: () => register(context),
child: Text("Register"),
),
],
),
),
);
}
}
File register_service.dart digunakan untuk mengelola proses registrasi pengguna
ke API server. Fungsinya:
- Registrasi (POST): Mengirimkan data pengguna baru (nama, email, password)
ke server.
Future<Map<String, dynamic>> registerUser(String name, String email, String
password) async {
final response = await [Link](
[Link]('[Link]
body: {'name': name, 'email': email, 'password': password},
);
if ([Link] == 200) {
return [Link]([Link]); // Respons sukses
} else {
throw Exception('Failed to register'); // Error
}
}
- Validasi Respons: Mengembalikan pesan sukses atau error dari server.
- Error Handling: Menangani kesalahan koneksi atau respons server.
File ini mendukung register_screen.dart dengan memisahkan logika registrasi
dari antarmuka pengguna, membuat kode lebih modular dan mudah dipelihara.

5. [Link]
import 'package:flutter/[Link]';
import 'screens/login_screen.dart';

void main() {
runApp(MyApp());
}

class MyApp extends StatelessWidget {

@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'RESTful API KEL 6',
theme: ThemeData(primarySwatch: [Link]),
home: LoginScreen(),
);
}
}
File [Link] adalah titik masuk utama aplikasi Flutter, yang digunakan untuk
menjalankan aplikasi dan menentukan struktur awalnya. Berikut penjelasan
singkat:
- Fungsi main(): Memanggil fungsi runApp() untuk memulai aplikasi Flutter.
void main() { runApp(MyApp()); }
- Kelas MyApp: Komponen utama aplikasi yang mewarisi StatelessWidget.
 MaterialApp: Menentukan kerangka aplikasi dengan tema, judul, dan
layar awal.
 home: Mengatur layar pertama yang ditampilkan, yaitu LoginScreen.
 theme: Mengatur tema aplikasi, seperti warna dasar blue.
class MyApp extends StatelessWidget { @override Widget
build(BuildContext context) { return MaterialApp( title: 'RESTful API
KEL 6', theme: ThemeData(primarySwatch: [Link]), home:
LoginScreen(), ); } }
Kesimpulan
 File ini menginisialisasi aplikasi dan mengarahkan pengguna ke layar login
sebagai tampilan pertama. Dengan struktur ini, aplikasi dapat dikelola secara
modular dan mempermudah pengembangan lebih lanjut.

B. restful_api_php>api>post>
1. [Link]
<?php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: POST");
header("Content-Type: application/json; charset=UTF-8");

include_once "../../config/[Link]";

$db = (new Database())->getConnection();

$data = json_decode(file_get_contents("php://input"));

if (!empty($data->user_id) && !empty($data->title) && !

empty($data->content)) {
$query = "INSERT INTO posts SET user_id=:user_id,
title=:title, content=:content, created_at=NOW()";
$stmt = $db->prepare($query);

$stmt->bindParam(":user_id", $data->user_id);
$stmt->bindParam(":title", $data->title);
$stmt->bindParam(":content", $data->content);

if ($stmt->execute()) {
http_response_code(200);
echo json_encode(["message" => "Post added
successfully"]);
} else {
http_response_code(500);
echo json_encode(["message" => "Unable to add post"]);
}
} else {
http_response_code(400);
echo json_encode(["message" => "Incomplete data"]);
}
[Link] adalah salah satu file API dalam sistem berbasis RESTful yang
digunakan untuk menambahkan data baru ke dalam basis data. Dalam konteks
ini, file ini digunakan untuk membuat entri baru pada tabel posts di database.
Proses ini biasanya dilakukan melalui permintaan HTTP POST, dengan data
dikirimkan dalam format JSON.
- Header Configuration
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: POST");
header("Content-Type: application/json; charset=UTF-8");
Tujuan : Konfigurasi awal untuk mendukung akses lintas origin (CORS) dan
menetapkan format data yang akan diterima.
 Access-Control-Allow-Origin: *: Mengizinkan semua domain untuk
mengakses API ini.
 Access-Control-Allow-Methods: POST: Menentukan bahwa metode
yang diperbolehkan untuk endpoint ini adalah POST.
 Content-Type: application/json; charset=UTF-8: Mengatur bahwa data
yang dikirim dan diterima berformat JSON.
- Koneksi ke Database
include_once "../../config/[Link]";
$db = (new Database())->getConnection();
Tujuan : Menyertakan file konfigurasi database ([Link]) dan membuat
koneksi ke database menggunakan objek Database.
- Mendapatkan dan Dekode Data Input
$data = json_decode(file_get_contents("php://input"));
Tujuan: mengambil data input dalam format JSON yang dikirim melalui body
permintaan HTTP POST dan mengonversinya menjadi objek PHP.
 php://input: Sebuah stream untuk membaca data mentah dari body
permintaan.
 json_decode(): Mengubah data JSON menjadi objek PHP.
- Validasi Data
if (!empty($data->user_id) && !empty($data->title) && !empty($data->content)) {
 Tujuan: Memeriksa apakah data yang dibutuhkan (user_id, title, dan content)
telah diisi. Jika salah satu kosong, maka sistem tidak akan melanjutkan proses
penyimpanan data.
- Query untuk Menyimpan Data
$query = "INSERT INTO posts SET user_id=:user_id, title=:title, content=:content,
created_at=NOW()";
$stmt = $db->prepare($query);
Tujuan: Membuat query SQL untuk menyisipkan data baru ke tabel posts.
 INSERT INTO posts: Perintah SQL untuk menambahkan baris baru ke
tabel posts.
 SET user_id=:user_id: Menetapkan nilai kolom menggunakan
placeholder.
 NOW(): Fungsi bawaan MySQL untuk menyisipkan waktu saat ini ke
kolom created_at.
- Binding Parameter
$stmt->bindParam(":user_id", $data->user_id);
$stmt->bindParam(":title", $data->title);
$stmt->bindParam(":content", $data->content);
Tujuan : Menghubungkan data dari permintaan ($data) ke placeholder
parameter dalam query SQL. Ini membantu mencegah serangan SQL
Injection.
- Eksekusi Query
if ($stmt->execute()) {
http_response_code(200);
echo json_encode(["message" => "Post added successfully"]);
} else
http_response_code(500);
echo json_encode(["message" => "Unable to add post"]);
}
Tujuan : Menjalankan query SQL yang telah disiapkan.
 Jika berhasil (execute() mengembalikan true): Mengirimkan respons
HTTP 200 dengan pesan sukses dalam format JSON.
 Jika gagal: Mengirimkan respons HTTP 500 dengan pesan gagal.
- Penanganan Jika Data Tidak Lengkap
 } else {
http_response_code(400);
echo json_encode(["message" => "Incomplete data"]);
}
Tujuan : Jika data input tidak lengkap, API mengirimkan respons HTTP 400
(Bad Request) dengan pesan kesalahan.
- Validasi Data
if (!empty($data->user_id) && !empty($data->title) && !empty($data-
>content)) {
Tujuan : Memeriksa apakah data yang dibutuhkan (user_id, title, dan content)
telah diisi. Jika salah satu kosong, maka sistem tidak akan melanjutkan proses
penyimpanan data.

2. [Link]
<?php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: DELETE");
header("Content-Type: application/json; charset=UTF-8");
include_once "../../config/[Link]";

$db = (new Database())->getConnection();

$data = json_decode(file_get_contents("php://input"));

// Validasi data
if (!empty($data->id) && !empty($data->user_id)) {
$query = "DELETE FROM posts WHERE id=:id AND
user_id=:user_id";
$stmt = $db->prepare($query);

$stmt->bindParam(":id", $data->id);
$stmt->bindParam(":user_id", $data->user_id);

if ($stmt->execute()) {
echo json_encode(["message" => "Post deleted
successfully"]);
} else {
http_response_code(500); // Internal server error
echo json_encode(["message" => "Unable to delete post"]);
}
} else {
http_response_code(400); // Bad request
echo json_encode(["message" => "Incomplete data"]);
}
?>
[Link] adalah sebuah file API berbasis RESTful yang digunakan untuk
menghapus data dari tabel tertentu di dalam database. Tujuannya adalah untuk
menghapus data dari tabel posts berdasarkan id dan user_id
- Header Konfigurasi
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: DELETE");
header("Content-Type: application/json; charset=UTF-8");
Mengatur header HTTP agar API dapat diakses dan memahami format data
yang digunakan.
 Access-Control-Allow-Origin: *
Mengizinkan permintaan API dari semua domain (tanpa pembatasan asal
permintaan).
 Access-Control-Allow-Methods: DELETE
Menentukan bahwa metode HTTP yang diizinkan untuk endpoint ini
adalah DELETE.
 Content-Type: application/json; charset=UTF-8
Menyatakan bahwa data yang dikirimkan dan diterima adalah dalam
format JSON dengan encoding UTF-8.
- Inklusi Database
include_once "../../config/[Link]";
$db = (new Database())->getConnection();
Menghubungkan file API ini dengan database
 include_once
Menyertakan file [Link], yang berisi konfigurasi untuk koneksi ke
database.
 getConnection()
Memanggil metode untuk mendapatkan koneksi database yang akan
digunakan untuk query SQL.
- Mendapatkan Input Data
$data = json_decode(file_get_contents("php://input"));
 Membaca data mentah yang dikirim melalui permintaan HTTP DELETE dan
mengonversinya dari format JSON ke objek PHP.
 file_get_contents("php://input")
Mengambil data mentah yang dikirim oleh klien (biasanya dalam format
JSON) melalui request body.
 json_decode()
Mengubah string JSON menjadi objek PHP agar lebih mudah diakses.
- Validasi Data
if (!empty($data->id) && !empty($data->user_id)) {
Memastikan bahwa properti id dan user_id dari input data tidak kosong. Jika
salah satu tidak ada, maka eksekusi akan dihentikan dengan status 400 Bad
Request.
- Query untuk Menghapus Data
$query = "DELETE FROM posts WHERE id=:id AND user_id=:user_id";
$stmt = $db->prepare($query);
Menyusun query SQL untuk menghapus data di tabel posts berdasarkan:
 id: ID unik dari posting yang akan dihapus.
 user_id: ID pengguna sebagai validasi tambahan agar hanya pemilik
posting yang dapat menghapusnya.
- Binding Parameter
$stmt->bindParam(":id", $data->id);
$stmt->bindParam(":user_id", $data->user_id);
Menghubungkan data input dari permintaan ($data) ke parameter dalam query
SQL (:id dan :user_id).
- Eksekusi Query
if ($stmt->execute()) {
echo json_encode(["message" => "Post deleted successfully"]);
} else {
http_response_code(500); // Internal server error
echo json_encode(["message" => "Unable to delete post"]);
}
Untuk Menjalankan query SQL untuk menghapus data:
  Jika berhasil (execute() mengembalikan true): Maka API mengirimkan
respons 200 OK dengan pesan sukses dalam format JSON.
 Jika gagal: Maka API mengirimkan respons 500 Internal Server Error
dengan pesan kesalahan.
- Penanganan Jika Data Tidak Lengkap
} else {
http_response_code(400); // Bad request
echo json_encode(["message" => "Incomplete data"]);
}
Jika data input tidak lengkap (misalnya, id atau user_id kosong), API akan
mengembalikan respons 400 Bad Request dengan pesan kesalahan.

3. [Link]
<?php
header("Content-Type: application/json");
include_once "../../config/[Link]";

$db = (new Database())->getConnection();

$query = "SELECT posts.*, [Link] AS author FROM posts JOIN

users ON posts.user_id = [Link]";
$stmt = $db->prepare($query);
$stmt->execute();

$posts = $stmt->fetchAll(PDO::FETCH_ASSOC);
echo json_encode($posts);
?>
Kode [Link] adalah bagian dari REST API yang digunakan untuk
membaca data dari database dan mengembalikannya dalam format JSON. Skrip ini
berfungsi untuk menampilkan daftar postingan dari tabel posts lengkap dengan
nama penulisnya dari tabel users.
- Header Konfigurasi
header("Content-Type: application/json");
Mengatur tipe konten respon menjadi JSON, memastikan klien memahami
bahwa data yang dikirimkan dalam format ini.
- Inklusi Koneksi Database
 include_once "../../config/[Link]";
$db = (new Database())->getConnection();
 include_once
Menyertakan file [Link], yang berisi informasi untuk
menghubungkan aplikasi dengan database.
 getConnection()
Memanggil metode untuk mendapatkan koneksi aktif ke database,
memungkinkan eksekusi query SQL.
- Query SQL
$query = "SELECT posts.*, [Link] AS author FROM posts JOIN users ON
posts.user_id = [Link]";
 SELECT posts.*
Memilih semua kolom dari tabel posts.
 [Link] AS author
Memilih kolom name dari tabel users dan menamakannya ulang menjadi
author dalam hasil query.
 FROM posts
Menentukan tabel utama (posts) yang akan diambil datanya.
 JOIN users ON posts.user_id = [Link]
Menggabungkan tabel posts dengan tabel users berdasarkan hubungan
user_id di tabel posts dan id di tabel users.
 Ini menghubungkan postingan dengan data penulisnya.
- Eksekusi Query
$stmt = $db->prepare($query);
$stmt->execute();
 $db->prepare($query)
Mempersiapkan query SQL sebelum dieksekusi untuk meningkatkan
keamanan dan kinerja.
 $stmt->execute()
Menjalankan query yang sudah dipersiapkan.
- Mengambil Hasil Query
 $posts = $stmt->fetchAll(PDO::FETCH_ASSOC);
 fetchAll(PDO::FETCH_ASSOC)
Mengambil semua hasil query dalam bentuk array asosiatif.
 Setiap baris data dikembalikan sebagai pasangan key => value, di
mana key adalah nama kolom.
- Respon JSON
echo json_encode($posts);
 json_encode($posts)
Mengonversi array hasil query menjadi format JSON agar mudah dibaca
oleh pengguna.

4. [Link]
<?php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: PUT");
header("Content-Type: application/json; charset=UTF-8");
include_once "../../config/[Link]";

$db = (new Database())->getConnection();

$data = json_decode(file_get_contents("php://input"));

// Validasi data
if (!empty($data->id) && !empty($data->user_id) && !empty($data-
>title) && !empty($data->content)) {
$query = "UPDATE posts SET title=:title, content=:content
WHERE id=:id AND user_id=:user_id";
$stmt = $db->prepare($query);

$stmt->bindParam(":id", $data->id);
$stmt->bindParam(":user_id", $data->user_id);
$stmt->bindParam(":title", $data->title);
$stmt->bindParam(":content", $data->content);

if ($stmt->execute()) {
echo json_encode(["message" => "Post updated
successfully"]);
} else {
http_response_code(500); // Internal server error
echo json_encode(["message" => "Unable to update post"]);
}
} else {
http_response_code(400); // Bad request
echo json_encode(["message" => "Incomplete data"]);
}
?>
[Link] digunakan untuk memperbarui data dalam tabel posts di database
berdasarkan id dan user_id.
- Header Konfigurasi
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: PUT");
header("Content-Type: application/json; charset=UTF-8");

 Access-Control-Allow-Origin: *
Mengizinkan permintaan dari semua domain (tanpa pembatasan asal
permintaan).
 Access-Control-Allow-Methods: PUT
Menentukan bahwa metode HTTP yang digunakan adalah PUT, sesuai
untuk operasi update.
 Content-Type: application/json
Mengatur tipe data yang dikirimkan dan diterima dalam format JSON.
- Inklusi Koneksi Database
include_once "../../config/[Link]";
$db = (new Database())->getConnection();

 include_once
Memuat file [Link] untuk mendapatkan konfigurasi koneksi
database.
 getConnection()
Membuat koneksi ke database untuk digunakan pada query SQL.
- Mengambil Input Data
$data = json_decode(file_get_contents("php://input"));
 file_get_contents("php://input")
Membaca data mentah yang dikirimkan melalui body permintaan HTTP.
 json_decode()
Mengonversi data JSON menjadi objek PHP agar dapat diakses.
- Validasi Input
if (!empty($data->id) && !empty($data->user_id) && !empty($data->title) && !
empty($data->content)) {
 Memastikan semua data yang diperlukan (id, user_id, title, content)
tersedia.
 Jika salah satu data tidak ada, akan mengembalikan status 400 Bad
Request.
- Query SQL untuk Update
$query = "UPDATE posts SET title=:title, content=:content WHERE id=:id AND
user_id=:user_id";
$stmt = $db->prepare($query);
 UPDATE posts
Menentukan tabel posts sebagai target operasi pembaruan data.
 SET title=:title, content=:content
Menentukan kolom yang akan diperbarui, yaitu title dan content.
 WHERE id=:id AND user_id=:user_id
Menentukan kondisi pembaruan:
 Data hanya diperbarui jika memiliki id yang sesuai.
o user_id harus cocok untuk memastikan hanya pengguna terkait yang
dapat memperbarui postingannya.
- Bind Parameters
$stmt->bindParam(":id", $data->id);
$stmt->bindParam(":user_id", $data->user_id);
$stmt->bindParam(":title", $data->title);
$stmt->bindParam(":content", $data->content);
 Menghubungkan parameter query SQL (:id, :user_id, :title, :content)
dengan nilai input yang diterima.
 Ini melindungi query dari serangan SQL Injection.
- Eksekusi Query dan Respon
if ($stmt->execute()) {
echo json_encode(["message" => "Post updated successfully"]);
} else {
http_response_code(500);
echo json_encode(["message" => "Unable to update post"]);
 }
 Berhasil: Maka, mengembalikan status 200 OK dengan pesan sukses:
"Post updated successfully".
 Gagal: Maka, akan mengembalikan status 500 Internal Server Error
dengan pesan: "Unable to update post".
- Penanganan Data Tidak Lengkap
http_response_code(400);
echo json_encode(["message" => "Incomplete data"]);
 Jika input data tidak lengkap, mengembalikan status 400 Bad Request
dengan pesan: "Incomplete data".

C. restful_api>api>user
1. [Link]
<?php
header("Content-Type: application/json");
include_once "../../config/[Link]";

$db = (new Database())->getConnection();

$data = json_decode(file_get_contents("php://input"));

if (!empty($data->email) && !empty($data->password)) {

$query = "SELECT * FROM users WHERE email = ?";
$stmt = $db->prepare($query);
$stmt->execute([$data->email]);
$user = $stmt->fetch(PDO::FETCH_ASSOC);

if ($user && password_verify($data->password,

$user['password'])) {
echo json_encode(["id" => $user['id'], "name" =>
$user['name']]);
} else {
echo json_encode(["message" => "Invalid email or
password"]);
}
} else {
echo json_encode(["message" => "Incomplete data"]);
}
?>
 Skrip ini adalah bagian dari REST API yang digunakan untuk memvalidasi
kredensial login (email dan password) pengguna. Jika validasi berhasil, skrip akan
mengembalikan data pengguna dalam format JSON.
- Header Konfigurasi
header("Content-Type: application/json");
Untuk mengatur tipe respon menjadi JSON, memastikan data yang dikirimkan
server dapat dipahami oleh klien.
- Inklusi Koneksi Database
include_once "../../config/[Link]";
$db = (new Database())->getConnection();
 include_once: Memuat file [Link] yang berisi konfigurasi untuk
koneksi database.
 getConnection(): Mendapatkan koneksi aktif ke database untuk
melakukan operasi SQL.
- Mengambil Data Input
$data = json_decode(file_get_contents("php://input"));
Untuk mengambil data input berupa JSON dari body permintaan HTTP dan
mengonversinya menjadi objek PHP.
- Validasi Data Input
if (!empty($data->email) && !empty($data->password)) {
Untuk memastikan bahwa data email dan password telah dikirim oleh klien.
Jika salah satu kosong, proses dihentikan dengan respon "Incomplete data".
- Menyiapkan dan Menjalankan Query SQL
$query = "SELECT * FROM users WHERE email = ?";
$stmt = $db->prepare($query);
$stmt->execute([$data->email]);
$user = $stmt->fetch(PDO::FETCH_ASSOC);
Dengan :

 SELECT * FROM users WHERE email = ?:

Query untuk mencari pengguna berdasarkan email. Penggunaan
placeholder (?) memastikan keamanan dari serangan SQL Injection.
  $stmt->execute([$data->email]):
Menjalankan query dengan parameter yang dikirimkan oleh pengguna.
 $stmt->fetch(PDO::FETCH_ASSOC):
Mengambil satu baris data pengguna dari database sebagai array asosiatif.
- Verifikasi Password
if ($user && password_verify($data->password, $user['password'])) {
Berfungsi untuk :

 Memeriksa apakah pengguna ditemukan di database.

 Memverifikasi apakah password yang dikirim pengguna cocok dengan
hash password yang tersimpan di database menggunakan fungsi
password_verify().
- Respon Autentikasi
 Jika autentikasi berhasil:
echo json_encode(["id" => $user['id'], "name" => $user['name']]);
Untuk mengembalikan data pengguna (ID dan nama) dalam format JSON.
 Jika autentikasi gagal:
echo json_encode(["message" => "Invalid email or password"]);
Yang bertujuan untuk mengembalikan pesan error jika email atau password
tidak valid.

Kesimpulan :
Skrip [Link] memproses autentikasi pengguna dengan langkah-langkah
berikut:
1. Membaca dan memvalidasi input dari klien.
2. Mengambil data pengguna berdasarkan email dari database.
3. Memverifikasi password yang diberikan terhadap hash password di
database.
4. Mengembalikan data pengguna jika login berhasil, atau pesan error jika
gagal.
2. [Link]
<?php
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: POST");
header("Content-Type: application/json; charset=UTF-8");
include_once "../../config/[Link]";

// Nonaktifkan PHP Notice agar tidak mengganggu respons JSON

ini_set('display_errors', 0);
ini_set('display_startup_errors', 0);
error_reporting(E_ALL & ~E_NOTICE);

$db = (new Database())->getConnection();

$data = json_decode(file_get_contents("php://input"));

// Pastikan semua data yang dibutuhkan tersedia

if (!empty($data->name) && !empty($data->email) && !empty($data-
>password)) {
// Simpan data dalam variabel sebelum dipass ke bindParam
$name = $data->name;
$email = $data->email;
$password = password_hash($data->password, PASSWORD_DEFAULT);

$query = "INSERT INTO users SET name=:name, email=:email,

password=:password";
$stmt = $db->prepare($query);

$stmt->bindParam(":name", $name);
$stmt->bindParam(":email", $email);
$stmt->bindParam(":password", $password);

// Eksekusi statement
 if ($stmt->execute()) {
http_response_code(200); // OK
echo json_encode(["message" => "User registered
successfully"]);
} else {
http_response_code(500); // Internal server error
echo json_encode(["message" => "Unable to register
user"]);
}
} else {
http_response_code(400); // Bad request
echo json_encode(["message" => "Incomplete data"]);
}
Skrip ini adalah bagian dari REST API yang digunakan untuk mendaftarkan
pengguna baru. Data pengguna dikirim melalui permintaan HTTP POST dalam
format JSON, kemudian disimpan ke dalam tabel users di database.
- Header Konfigurasi
header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Methods: POST");
header("Content-Type: application/json; charset=UTF-8");
Tujuan:
 Access-Control-Allow-Origin: *: Mengizinkan permintaan dari domain
mana pun (CORS).
 Access-Control-Allow-Methods: POST: Membatasi metode HTTP
yang diizinkan hanya untuk POST.
 Content-Type: application/json; charset=UTF-8: Mengatur tipe konten
respons menjadi JSON dan menggunakan karakter encoding UTF-8.
- Penanganan Error
ini_set('display_errors', 0);
ini_set('display_startup_errors', 0);
error_reporting(E_ALL & ~E_NOTICE);
Untuk menonaktifkan notifikasi error PHP untuk mencegah output error yang
dapat mengganggu format JSON.
- Inklusi Koneksi Database
include_once "../../config/[Link]";
$db = (new Database())->getConnection();
Tujuan:
  Memuat file [Link] untuk mengatur koneksi ke database.
 Mendapatkan koneksi aktif melalui metode getConnection().
- Mengambil Data Input
$data = json_decode(file_get_contents("php://input"));
Untuk membaca data mentah (raw data) dari body permintaan HTTP POST
dan mengonversinya menjadi objek PHP untuk memudahkan akses ke properti
seperti $data->name, $data->email, dan $data->password.
- Validasi Data Input
if (!empty($data->name) && !empty($data->email) && !empty($data->password)) {
Untuk memastikan bahwa data yang diperlukan (nama, email, dan password)
tidak kosong. Jika salah satu kosong, proses dihentikan dengan respon
"Incomplete data".
- Menyiapkan Data untuk Disimpan
$name = $data->name;
$email = $data->email;
$password = password_hash($data->password, PASSWORD_DEFAULT);
Tujuan:
 $name dan $email: Menyimpan data nama dan email dari input.
 password_hash(): Mengenskripsi password dengan algoritma hashing
yang aman untuk disimpan di database.
- Menyiapkan dan Menjalankan Query SQL
$query = "INSERT INTO users SET name=:name, email=:email,
password=:password";
$stmt = $db->prepare($query);
$stmt->bindParam(":name", $name);
$stmt->bindParam(":email", $email);
$stmt->bindParam(":password", $password);
Tujuan:
 INSERT INTO users: Menambahkan data pengguna baru ke tabel users.
 bindParam(): Mengikat nilai variabel ke parameter query untuk
mencegah serangan SQL Injection.
 $stmt->execute(): Menjalankan query untuk menyimpan data ke
database.
- Menangani Hasil Eksekusi
 Jika berhasil:
http_response_code(200);
echo json_encode(["message" => "User registered successfully"]);
Maka akan merespons sukses dengan kode status 200 OK dan pesan JSON
"User registered successfully".
 Jika gagal:
http_response_code(500);
echo json_encode(["message" => "Unable to register user"]);
Maka akan memberikan respons gagal dengan kode status 500 Internal
Server Error dan pesan JSON "Unable to register user".
- Menangani Data Tidak Lengkap
http_response_code(400);
echo json_encode(["message" => "Incomplete data"]);
Maka muncul respons error jika data input (name, email, atau password) tidak
lengkap, dengan kode status 400 Bad Request.

Kesimpulan: Skrip [Link] berfungsi untuk menerima data pengguna baru

melalui permintaan HTTP POST, memvalidasi data tersebut, mengenskripsi
password, dan menyimpan data ke dalam tabel users. Respons JSON
dikembalikan untuk memberi tahu klien tentang keberhasilan atau kegagalan
pendaftaran.
D.restful_api_php>api>config
1. [Link]
<?php
class Database {
private $host = "localhost";
private $db_name = "restful_db";
private $username = "root";
private $password = "";
public $conn;

public function getConnection() {

$this->conn = null;
try {
$this->conn = new PDO("mysql:host=" . $this->host .
";dbname=" . $this->db_name, $this->username, $this->password);
$this->conn->setAttribute(PDO::ATTR_ERRMODE,
PDO::ERRMODE_EXCEPTION);
} catch (PDOException $exception) {
echo "Connection error: " . $exception->getMessage();
}
return $this->conn;
}
}
?>
Skrip ini mendefinisikan kelas Database, yang digunakan untuk mengatur koneksi
ke database MySQL dalam aplikasi berbasis PHP.
- Deklarasi Kelas Database
class Database {
private $host = "localhost";
private $db_name = "restful_db";
private $username = "root";
 private $password = "";
public $conn;
}
Dengan fungsi:
 $host: Menyimpan alamat server database (dalam hal ini localhost).
 $db_name: Menyimpan nama database yang akan digunakan
(restful_db).
 $username: Menyimpan username database (root).
 $password: Menyimpan password database (kosong dalam konfigurasi
default XAMPP/LAMP).
 $conn: Variabel untuk menyimpan koneksi aktif ke database.
- Metode getConnection
public function getConnection() {
$this->conn = null;
try {
$this->conn = new PDO("mysql:host=" . $this->host . ";dbname=" . $this->db_name,
$this->username, $this->password);
$this->conn->setAttribute(PDO::ATTR_ERRMODE,
PDO::ERRMODE_EXCEPTION);
} catch (PDOException $exception) {
echo "Connection error: " . $exception->getMessage();
}
return $this->conn;
}
Bertujuan untuk membuat koneksi ke database menggunakan PDO (PHP
Data Objects), yang merupakan cara aman dan fleksibel untuk berinteraksi
dengan database.

File [Link] menyediakan mekanisme untuk mengatur koneksi ke

database MySQL menggunakan PDO. Dengan menggunakan kelas Database,
koneksi dapat diakses di bagian lain aplikasi menggunakan metode
getConnection(). Skrip ini memastikan koneksi aman, mudah dikelola, dan
dapat menangani kesalahan dengan baik.
E. Interface
1. Home

Menambah Data: Form input dengan dua field, yaitu Title dan Content. Setelah data
diisi, pengguna dapat menekan tombol "Add Post" untuk menambahkan data ke
dalam daftar. Menampilkan Data: Daftar data yang telah ditambahkan muncul di
bawah form input. Mengedit Data: Setiap data memiliki ikon edit (pensil) untuk
memperbarui informasi. Menghapus Data: Setiap data memiliki ikon delete (tempat
sampah) untuk menghapus informasi dari daftar.
2. Register

Field Input:
Name: Untuk mengisi nama pengguna.
Email: Untuk alamat email pengguna.
Password: Untuk keamanan akun pengguna.
Tombol Register: Mengirim data pengguna ke server atau sistem backend untuk
pembuatan akun baru.

Navigasi:
Navigasi terlihat responsif dengan tombol "kembali" di atas (back button),
memungkinkan pengguna kembali ke halaman sebelumnya.
Potensi Backend:
Data dari form ini dapat dikirim ke REST API menggunakan metode POST untuk
disimpan di database.
 Validasi data (contoh: format email atau kekuatan kata sandi) bisa dilakukan sebelum
pengiriman data ke server.
3. Login
Field Input: Email: Untuk alamat email pengguna. Password: Untuk autentikasi akun
pengguna. Tombol Login: Memproses data input untuk verifikasi pengguna dengan
sistem backend. Navigasi: Tautan "Register here": Membantu pengguna yang belum
memiliki akun untuk diarahkan ke halaman registrasi
 BAB III
KESIMPULAN DAN SARAN

3.1 KESIMPULAN
Aplikasi notes telah menjadi solusi praktis dan efisien dalam mengelola
informasi di era digital. Dengan fitur-fitur seperti kemudahan akses, kemampuan
sinkronisasi, pengingat, dan dukungan kolaborasi, aplikasi ini memberikan kontribusi
besar terhadap produktivitas individu maupun kelompok. Selain itu, aplikasi notes
juga membantu mengurangi ketergantungan pada media fisik, sehingga mendukung
keberlanjutan lingkungan. Namun, untuk tetap relevan di tengah persaingan yang
ketat, aplikasi notes harus terus berinovasi, terutama dalam aspek keamanan data,
antarmuka yang ramah pengguna, dan kemampuan untuk memenuhi kebutuhan
pengguna yang semakin kompleks.

3.2 SARAN
3.2.1 Pengembangan Fitur yang Adaptif
Pengembang aplikasi notes disarankan untuk menambahkan fitur berbasis
kecerdasan buatan, seperti pengenalan tulisan tangan, analisis catatan, atau
pengelompokan otomatis, untuk memberikan pengalaman yang lebih personal dan
canggih bagi pengguna.
3.2.2 Interopabilitas Antar Platform
Untuk memudahkan pengguna yang menggunakan berbagai perangkat,
aplikasi notes sebaiknya terus meningkatkan kemampuan sinkronisasi dan
kompatibilitas dengan aplikasi lain seperti kalender atau aplikasi manajemen tugas.
3.2.3 Pendidikan Pengguna
Disarankan adanya panduan atau pelatihan untuk pengguna baru agar mereka
dapat memanfaatkan seluruh fitur aplikasi secara optimal.