Mulai Membuat Blog Anda Dengan Parse.js: Migrasikan Server Parse Anda Sendiri

() translation by (you can also view the original English article)

Final product image — What You'll Be Creating

Sayangnya, Parse.com ditutup pada 28 Januari 2017. Di seri sebelumnya, saya memandu Anda melalui seluruh perjalanan membangun sistem blog dari awal. Tapi semuanya didasarkan pada Parse.com, dan jika Anda masih menggunakan teknik tersebut, situs web Anda sayangnya akan berhenti bekerja saat itu.

Jika Anda masih menyukai Parse.js (seperti halnya saya), dan ingin terus menggunakannya, ada kabar baik. Orang-orang yang menyenangkan di sana membuatnya menjadi open source sehingga kami dapat menjalankan salinan kami sendiri di semua layanan hosting web populer. Tutorial ini bertujuan untuk membantu Anda membuat perubahan itu dan bermigrasi dari Parse.com ke Server Parse Anda sendiri di Heroku.

Saya bukan ahli di bidang back end, tetapi ini cara termudah yang saya temukan yang berhasil. Jika Anda melihat ada kekurangan dan memiliki metode yang lebih baik untuk dibagikan, pasti berikan komentar di bawah ini.

Jika Anda mengikuti episode ini, migrasi server dengan sendirinya tidak akan terlalu rumit. Dengan Docker, bahkan cukup mudah untuk menyiapkan Dasbor Parse lokal, sehingga Anda masih dapat melihat dan bermain dengan data Anda dengan mudah.

Namun, seri tutorial ini dibuat berdasarkan versi 1.2.19 dari Parse.js; untuk terhubung ke server Parse yang berdiri sendiri, kita perlu memperbarui aplikasi untuk menjalankan versi 1.9.2. Dengan versi 1.5.0, Parse mengambil dukungan untuk Backbone, dan itu berarti kita memerlukan beberapa perubahan besar dalam kode. Kami akan menambahkan Backbone kembali ke halaman, dan menggunakan campuran Parse dan Backbone di sana.

Itu intro yang cukup panjang, tetapi jangan terlalu takut. Anda mungkin perlu melakukan debug di sana-sini selama migrasi, tetapi Anda akan baik-baik saja. Anda selalu dapat memeriksa source code saya atau memberikan komentar di bawah ini — Saya dan komunitas fantastis ini di sini akan mencoba yang terbaik untuk membantu Anda.

Mengatur dan bermigrasi ke Server Parse

Pertama-tama, mari kita mulai membuat Server Parse. Parse sudah membuat ini sangat mudah dengan panduan migrasi terperinci dan daftar panjang aplikasi sampel di semua platform populer seperti Heroku, AWS, dan Azure.

Saya akan memandu Anda melalui yang paling mudah yang saya tahu: kombinasi Heroku + mLab. Ini bebas untuk memulai, dan Anda selalu dapat membayar untuk perangkat keras yang lebih baik dan lebih banyak penyimpanan dalam sistem yang sama. Satu-satunya peringatan adalah bahwa versi gratis dari Heroku akan 'sleep' setelah diam selama 30 menit. Jadi, jika pengguna mengunjungi situs Anda ketika server 'sleep', mereka mungkin harus menunggu beberapa detik agar server bangun sebelum mereka dapat melihat data. (Jika Anda memeriksa halaman demo untuk proyek ini dan tidak membuat konten blog apa pun, itulah sebabnya. Beri waktu sebentar dan segarkan.)

Bagian ini sebagian besar didasarkan pada panduan Heroku untuk Menyebarkan Parse Server dan panduan migrasi Parse sendiri. Saya hanya memilih jalan yang paling sederhana dan paling mudah dibobol di sana.

Langkah 1: Mendaftar dan Membuat sebuah Aplikasi Baru pada Heroku

Jika Anda belum memiliki akun Heroku, lanjutkan dan membuatnya. Ini adalah platform yang sangat populer untuk mengembangkan dan menghosting aplikasi web kecil.

Setelah Anda terdaftar, buka Dasbor Heroku Anda dan buat aplikasi baru — yang akan menjadi server Anda.

Beri nama jika Anda ingin:

Langkah 2: Tambahkan mLab MongoDB

Sekarang Anda perlu database untuk menyimpan data. Dan mari kita tambahkan mLab sebagai add-on.

Pergi ke Resources > Add-ons, temukan "mLab", dan tambahkan:

Sandbox cukup untuk pengembangan — Anda selalu dapat meningkatkan dan membayar lebih banyak untuk mendapatkan lebih banyak penyimpanan di sana.

Setelah Anda menambahkan mLab, Anda dapat mengambil URI MongoDB itu.

Buka Settings > Config Variables di Dasbor Heroku Anda dan klik pada Reveal Config Vars.

Di sana Anda dapat melihat URI MongoDB untuk database Anda. Salin, dan sekarang kita dapat mulai memigrasi database.

Langkah 3: Migrasi Database

Buka Parse.com dan temukan aplikasi yang ingin Anda migrasikan. Versi open-source dari Parse Server hanya mendukung satu aplikasi per server, jadi jika Anda ingin memiliki beberapa aplikasi, Anda perlu mengulangi proses ini dan membuat beberapa server. Sekarang pilih satu saja.

Dalam aplikasi, pergi ke App Settings > General > App Manajement, lalu klik Migrate.

Lalu tempelkan URI MongoDB yang baru saja Anda salin, dan mulai migrasi.

Segera Anda akan melihat layar ini:

Itu berarti sekarang Anda harus memiliki semua data dalam mLab MongoDB Anda. Mudah saja, kan?

Tetapi belum menyelesaikan aplikasi Anda — tunggu saja sampai kita dapat melihat dan bermain dengan data yang sama dari Dasbor Parse lokal kami, kemudian kembali dan selesaikan.

Langkah 4: Menyebarkan Server Parse

Sekarang, dengan database sudah bermigrasi, kita bisa menyebarkan Server Parse.

Jika Anda belum memiliki akun GitHub, lanjutkan dan membuatnya. Itu mungkin tempat paling populer di mana orang berbagi dan mengelola kode mereka.

Dengan akun GitHub Anda, pilih contoh repo Server Parse resmi.

Kemudian, kembali ke Dasbor Heroku Anda. Pada Deploy > Deployment method, pilih GitHub dan hubungkan ke akun GitHub Anda.

Setelah itu, cari parse dan temukan repo parse-server-example Anda dan hubungkan.

Jika semuanya bekerja, Anda harus melihatnya terhubung seperti ini:

Sekarang, gulir ke bawah ke bagian bawah halaman. Di bawah Manual Deploy, klik Deploy Branch.

Anda akan melihat Server Parse Anda sedang di deploy, dan segera Anda akan melihat layar ini:

Klik pada tombol View dan Anda akan melihat halaman ini:

Itu berarti server Anda sekarang berjalan dengan gembira! Dan URL yang Anda lihat adalah URL server Anda. Anda akan membutuhkannya nanti.

Saya tahu rasanya tidak nyata untuk melihat garis sederhana ini dan mengetahui bahwa server sudah siap. Tapi percayalah, pembangkit tenaga listrik sedang berjalan di sana. Dan aplikasi Anda dapat membaca dan menulis darinya.

Jika Anda ingin Periksa, Anda dapat menjalankan sesuatu seperti ini:

$ curl -X POST \
  -H "X-Parse-Application-Id: myAppId" \
  -H "Content-Type: application/json" \
  -d '{}' \
  https://example.herokuapp.com/parse/functions/hello
..
{"result":"Hi"}%

Mengatur Dasbor Parse Lokal

Jika Anda seorang ninja command-line, Anda mungkin akan baik-baik saja dari sini. Tetapi jika Anda seperti saya dan menikmati antarmuka Dasbor Parse yang ramah, ikuti bagian ini untuk menyiapkan Dasbor Parse Anda sendiri di komputer lokal Anda, sehingga Anda dapat melihat dan bermain dengan data Parse seperti yang biasa Anda lakukan.

Sekali lagi, Anda dapat menginstal dasbor Anda dalam beberapa cara. Saya hanya akan menunjukkan kepada Anda cara paling sederhana dalam pengalaman saya, menggunakan Docker.

Langkah 1: Instal Docker

Jika Anda tidak memiliki Docker, install terlebih dahulu (Mac | Windows).

Ini menempatkan seluruh lingkungan dalam box, jadi Anda tidak perlu mengikuti tutorial instalasi lokal yang cukup rumit dan melompat melalui hoop di Terminal.

Langkah 2: Buat Gambar Dasbor Parse

Dengan docker Anda menjalankan, mengkloning repo Dasbor Parse ke komputer Anda dan masuk ke repo itu.

$ git clone https://github.com/ParsePlatform/parse-dashboard.git
Cloning into 'parse-dashboard'...
remote: Counting objects: 3355, done.
remote: Total 3355 (delta 0), reused 0 (delta 0), pack-reused 3354
Receiving objects: 100% (3355/3355), 2.75 MiB | 2.17 MiB/s, done.
Resolving deltas: 100% (1971/1971), done.
$ cd parse-dashboard/

Untuk pemula GitHub mutlak, cukup unduh sebagai file zip.

Buka zip dan letakkan di lokasi yang dapat Anda ingat. Buka aplikasi terminal Anda jika Anda menggunakan Mac, ketik cd (Anda memerlukan spasi setelah cd di sana) dan seret folder ke dalamnya.

Lalu tekan Enter.

Anda harus melihat sesuatu seperti ini, dan itu berarti Anda berada di tempat yang benar.

1	~$ cd /Users/moyicat/temp/parse-dashboard-master
2	~/temp/parse-dashboard-master$

Sekarang, Anda dapat dengan cepat memeriksa apakah Docker Anda dipasang dengan benar dengan menempel di perintah ini:

docker -v

Jika ini menunjukkan versi Anda, seperti ini:

1	Docker version 1.12.5, build 7392c3b

Sudah terpasang, dan Anda dapat melanjutkan.

Jika sebaliknya, ia mengatakan:

1	-bash: docker: command not found

Anda perlu memeriksa ulang apakah Anda telah menginstal Docker dengan benar.

Dengan Docker terpasang dengan benar, tempelkan perintah ini dan tekan Enter:

1	docker build -t parse-dashboard .

Itu akan membuat Anda gambar lokal (jangan ragu untuk mengabaikan jargon docker) untuk Dasbor Parse.

Anda akan melihat banyak baris bergulir. Jangan panik — hanya sebentar, dan Anda akan melihatnya berakhir dengan sesuatu seperti ini:

1	Successfully built eda023ee596d

Itu berarti Anda selesai — gambar telah berhasil dibuat.

Jika Anda menjalankan perintah docker images, Anda akan melihat:

1	REPOSITORY TAG IMAGE ID CREATED SIZE
2	parse-dashboard latest eda023ee596d About a minute ago 778.1 MB

Langkah 3: Hubungkan Parse Dashboard ke Parse Server

Sekarang, itu hanya sebuah gambar, dan itu bukan server yang berjalan. Ketika berjalan, kita ingin terhubung ke Server Parse dan MongoDB yang baru saja kita bangun.

Untuk melakukan itu, pertama-tama kita perlu membuat beberapa key di Heroku, sehingga dapat memberi tahu siapa yang memberi akses ke data.

Pergi ke Heroku Dashboard Anda dan pergi ke Settings > Config Variables lagi. Kali ini, kita perlu menambahkan dua variabel di sana: APP_ID dan MASTER_KEY. APP_ID dapat menjadi sesuatu yang mudah diingat, sementara MASTER_KEY sebaiknya menjadi kata sandi yang sangat panjang dan rumit.

Sekarang dengan key tersebut, kita dapat menulis file konfigurasi sederhana di direktori root dari folder Parse Dashboard Anda. Anda dapat menggunakan semuanya dari vim ke TextEdit atau Notepad — tujuannya adalah membuat file config.json teks biasa dengan konten ini:

{
  "apps": [{
    "serverURL": "your-app-url/parse",
    "appId": "your-app-id",
    "masterKey": "your-master-key",
    "appName": "your-app-name"
  }],
  "users": [{
    "user":"user",
    "pass":"pass"
  }]
}

Dan tentu saja, gantilah your-app-url dengan URL tautan “View” (halaman yang mengatakan “Saya bermimpi menjadi situs web”), tetapi simpanlah /parse di sana di bagian akhir; ganti your-app-id dan your-master-key dengan variabel-variabel konfigurasi yang baru saja Anda tambahkan; dan berikan nama pada aplikasi Anda dan ganti your-app-name dengan itu.

Simpan file dan jalankan perintah ls di Terminal untuk memastikan Anda meletakkan config.json di tempat yang benar.

1	~/temp/parse-dashboard-master$ ls
2	CHANGELOG.md Dockerfile PIG/ Procfile bin/ package.json src/ webpack/
3	CONTRIBUTING.md LICENSE Parse-Dashboard/ README.md config.json scripts/ testing/''

Jika Anda melihat config.json dalam daftar ini, Anda sebaiknya melanjutkan.

Sekarang jalankan perintah pwd untuk mendapatkan tempat Anda berada:

1	$ pwd
2	/Users/moyicat/temp/parse-dashboard-master

Salin path itu.

Kemudian tempelkan perintah ini untuk membuat container Docker (lagi, Anda dapat mengabaikan jargon ini) dan jalankan Dasbor Parse Anda. Ingatlah untuk mengganti jalur saya dengan jalan yang baru saja Anda dapatkan.

docker run -d \
           -p 8080:4040 \
           -v /Users/moyicat/temp/parse-dashboard-master/config.json:/src/Parse-Dashboard/parse-dashboard-config.json \
           -e PARSE_DASHBOARD_ALLOW_INSECURE_HTTP=1 \
           --name parse-dashboard \
           parse-dashboard

Dari atas ke bawah, perintah ini melakukan hal-hal ini (yang juga dapat Anda abaikan):

L1: Tell Docker to start a container 
L2: Make it run on port 8080, you can change it to any port you want
L3: Get the config.json you just made as use it as the configuration
L4: Enable HTTPS on your local (otherwise you will meet an error message)
L5: Give it a name you can remember. You can change it to anything you want, too.
L6: Tell Docker the image you want to use. parse-dashboard is the name we used in the docker build command earlier.

Jika semuanya berjalan, itu akan mengembalikan string panjang kepada Anda tanpa pesan kesalahan. Seperti ini:

1	4599aab0363d64373524cfa199dc0013a74955c9e35c1a43f7c5176363a45e1e

Dan sekarang Dasbor Parse Anda sedang berjalan! Lihat di http://localhost:8080/.

Mungkin lambat dan menunjukkan halaman kosong pada awalnya, tetapi hanya berikan beberapa menit dan Anda akan melihat layar masuk:

Sekarang Anda dapat masuk dengan user sebagai nama pengguna dan pass sebagai kata sandi — itu didefinisikan dalam config.json jika Anda tidak menyadari sebelumnya. Anda juga dapat mengubahnya ke apa pun yang Anda inginkan.

Dan Anda akan melihat antarmuka yang familiar ini dari mesin lokal Anda dan dapat bermain dengan data Anda (sekarang dalam mLab MongoDB) seperti yang selalu Anda lakukan.

Beberapa catatan akhir di dasbor lokal ini:

Pertama, Anda dapat menghentikan dan memulai container ini mulai sekarang kapan saja dengan dua perintah ini:

1	docker stop parse-dashboard
2	docker start parse-dashboard

Jadi ketika Anda me-restart komputer Anda, Anda tidak perlu mengikuti langkah-langkah sebelumnya lagi, cukup katakan untuk memulai lagi.

Dan kedua, jika Anda memiliki beberapa server Parse, Anda tidak perlu membuat beberapa dasbor Parse. Cukup tambahkan beberapa aplikasi di config.json seperti ini:

{
  "apps": [{ // info for first server
    "serverURL": "",
    "appId": "",
    "masterKey": "",
    "appName": ""
  }, { // info for second server
    "serverURL": "",
    "appId": "",
    "masterKey": "",
    "appName": ""
  }],
  "users": [...],
}

Setiap kali Anda membuat perubahan pada config.json, Anda perlu me-restart container Docker:

1	docker restart parse-dashboard

Dan kemudian Anda akan melihat perubahan yang Anda buat.

Langkah 4: Menyelesaikan migrasi

Sekarang mainkan dengan Dasbor Parse baru Anda, dan jika semuanya berfungsi, Anda sekarang dapat kembali ke Parse.com dan menyelesaikan migrasi.

Kemudian, jika Anda memeriksa aplikasi dan dasbor, Anda akan menemukan bahwa semuanya secara ajaib mengarah ke server baru Anda tanpa masalah.

Perbarui Kode untuk Dijalankan pada Parse 1.9.2

Ini hebat! Saya berharap itu bisa tetap seperti itu dan kita bisa mengakhiri tutorial ini lebih awal. Tapi seperti yang saya sebutkan, aplikasi Parse.js lama Anda masih mengandalkan server Parse.com untuk mengarahkannya ke server baru yang benar. Dan itu akan berhenti berfungsi setelah 28 Januari 2017.

Untuk membuatnya berjalan selamanya (finger crossed) kita perlu berhenti menggunakan tombol JavaScript untuk menunjuk ke aplikasi (yang bergantung pada Parse.com untuk mencari tahu ke database mana), dan langsung menunjuk ke server parse kita.

Langkah 1: Perbarui JavaScript Libraries

Pertama mari kita update file Parse.js yang kami gunakan di index.html.

Daripada menggunakan versi 1.2.19:

1	<script src="//www.parsecdn.com/js/parse-1.2.19.min.js"></script>

Beralih ke versi terbaru:

1	<script src="//npmcdn.com/parse/dist/parse.min.js"></script>

Selain itu, mari tambahkan Lodash dan Backbone. Sekarang Parse telah berhenti mendukung Backbone, kita perlu memasukkannya agar tetap menggunakan Views dan Router.

1	<!-- Lodash -->
2	<script src="//cdn.jsdelivr.net/lodash/4.17.3/lodash.min.js"></script>
3	<!-- Backbone.js -->
4	<script src="//cdnjs.cloudflare.com/ajax/libs/backbone.js/1.3.3/backbone-min.js"></script>

Langkah 2: Arahkan ke Server Parse Anda

Kemudian, mari masuk ke site.js.

Hal pertama yang ada adalah memperbarui fungsi Parse.initialize() sehingga mengarah ke Server Parse Anda sendiri.

Sebelumnya mungkin terlihat seperti ini:

1	Parse.initialize("HC87tn6aA7c3sYx9X0vwwLVXeqHDRMYYmrUBK5zv", "3piNGGnRMhvWo8u9pKD9TDc1MJlWhlvK78Vr3fHo");

Sekarang, arahkan ke server Parse.

1	Parse.initialize("moyicat-parse-blog-git"); // Your App Name
2	Parse.serverURL = 'https://moyicat-parse-blog-git.herokuapp.com/parse'; // Your Server URL

Langkah 3: Dari React ke Backbone

Teruskan, mari lakukan pembaruan cepat untuk mengubah semua Parse.View, Parse.Router, dan Parse.history menjadi Backbone.View, Backbone.Router, dan Backbone.history. Itu tidak lagi didukung oleh Parse, jadi kita perlu memiliki fallback.

Ini bukan hal yang paling menyenangkan di dunia untuk mencampur dan mencocokkan Class seperti itu, tetapi jika Anda ingin sedikit mengubah kode dan menjalankannya, ini mungkin cara termudah.

Langkah 4: Dari Collection ke Query; Dari `fetch` ke `find`

Sekarang, satu hal lain yang Parse berhenti mendukung adalah Collection. Dan itu jauh lebih berduri daripada tiga lainnya. Beralih dari Parse.Collection ke Backbone.Collection tidak akan berfungsi. Kita perlu menulis ulang logika menggunakan Parse queries.

Saya akan menggunakan koleksi Blogs sebagai contoh untuk menunjukkan kepada Anda bagaimana kami dapat memperbarui blog kami untuk bekerja dengan Parse.js yang baru.

Sebelumnya, pertama kali kita didefinisikan Class untuk Blogs:

1	Blogs = Parse.Collection.extend({
2	model: Blog,
3	query: (new Parse.Query(Blog)).descending('createdAt')
4	});

Dan kemudian di fungsi BlogRouter.start() kami membuat sebuah instance dari kelas itu untuk menampung koleksi blok.

1	this.blogs = new Blogs();

Setelah itu, kami memanggil fetch() pada koleksi itu untuk mendapatkan data blog. Seperti di BlogRouter.index():

1	this.blogs.fetch({
2	success: function(blogs) {...},
3	error: function(blogs, error) {...}
4	});

Sekarang, kita bisa menghapus deklarasi Class itu dan membuat BlogRouter.blogs sebuah query Parse:

1	this.blogs = new Parse.Query(Blog).descending('createdAt');

Dan ketika kita menyebutnya, bukan fetch() kita gunakan find().

1	this.blogs.find({
2	success: function(blogs) {...},
3	error: function(blogs, error) {...}
4	});

Bagian ini mungkin memakan waktu cukup lama karena kami memiliki beberapa kasus penggunaan yang berbeda selama seri ini. Anda mungkin perlu melakukan debug sedikit — pada titik ini, bahkan jika data diambil dengan benar, halaman belum akan ditampilkan dengan benar. Jika Anda lebih suka melihat hal-hal berubah saat Anda memperbaikinya, baca sampai akhir, dan kemudian mulai mengubah kode dan debugging Anda.

Langkah 5: Periksa View Objects

Ketika semua data diambil dengan benar, hal berikutnya untuk diperiksa adalah data yang Anda berikan ke objek View Anda.

Sebelumnya, kita bisa melewati apapun yang kita inginkan ke objek View. Dalam contoh ini, kami memberikan username secara langsung ke dalam blogAdminView sehingga kami dapat menyapa pengguna dengan nama pengguna mereka.

1	var blogsAdminView = new BlogsAdminView({
2	username: currentUser.get('username'),
3	collection: blogs
4	});

Ini juga akan berhenti bekerja ketika kita mengubah View untuk diperpanjang dari objek Backbone.View. Kami hanya bisa lulus dalam model dan collection sekarang.

Jadi kita harus meneruskan currentUser sebagai model:

1	var blogsAdminView = new BlogsAdminView({
2	model: currentUser,
3	collection: blogs
4	});

Dan ubah BlogsAdminView sesuai.

Sekali lagi, Anda mungkin perlu menguji dan men-debug sedikit untuk membuat semuanya bekerja.

Langkah 6: Perbarui Template Handlebar untuk Beradaptasi dengan Struktur Data Baru

Dan akhirnya, antara perubahan versi, struktur data Objek Parse juga berubah sedikit.

Sebelumnya, setiap objek terlihat seperti ini:

1	{
2	objectId: '',
3	title: '',
4	...,
5	}

Sekarang, ini adalah struktur baru:

{
    id: '' // the objectId,
	attributes: {
		title: '',
		...,
	},
	...,
}

Ini berarti kita perlu memperbarui template Handlebar kita, juga, untuk membuat data baru dengan benar:

Misalnya, sebelumnya untuk kategori di sidebar kami menulis template berikut:

<script id="categories-tpl" type="text/x-handlebars-template">
    <div class="sidebar-module">
		<h4>Categories</h4>
		<ol class="list-unstyled">
		{{#each category}}
		<li><a href="#/category/{{objectId}}">{{name}}</a></li>
		{{/each}}
		</ol>
	</div>
</script>

Sekarang kita perlu memperbarui {{objectId}} menjadi {{id}} dan {{name}} menjadi {{atribut.name}}.

<script id="categories-tpl" type="text/x-handlebars-template">
    <div class="sidebar-module">
		<h4>Categories</h4>
		<ol class="list-unstyled">
		{{#each category}}
		<li><a href="#/category/{{id}}">{{attributes.name}}</a></li>
		{{/each}}
		</ol>
	</div>
</script>

Sekarang halaman Anda akan render.

Sekali lagi, jika Anda tidak ingat logika situs sepenuhnya dengan jelas, Anda mungkin perlu melompati beberapa lingkaran sedikit di sini. Jika Anda terjebak, Anda selalu dapat memeriksa source code saya.

Kesimpulan

Di sana Anda memilikinya. Semoga ini dapat membantu Anda menyimpan data Anda sebelum Parse.com mati - atau hidupkan kembali kode Anda saat Anda membutuhkannya. Anda akan kehilangan semua data setelah 28 Januari 2017, tetapi jika Anda memperbarui kode, itu akan berfungsi kembali.

Sekali lagi, saya sangat sedih Parse.com tidak akan berjalan lagi dan seri tutorial ini tidak akan berfungsi untuk pendatang baru (kecuali mereka tetap mengacu kembali ke bagian akhir ini). Tapi semoga itu membantu beberapa orang untuk belajar cara membuat kode situs web.

Mulai saat ini, apakah Anda memilih untuk bermigrasi atau belajar bahasa baru, itu sepenuhnya terserah Anda. Saya berharap ini akan menjadi sedikit lebih mudah karena Anda belajar beberapa konsep yang berguna di sini.

Semoga sukses! Dan tinggalkan saya komentar jika Anda menemukan seri ini bermanfaat.