diff --git a/erpnext/translations/id.csv b/erpnext/translations/id.csv
index dc4deeb..22d69e1 100644
--- a/erpnext/translations/id.csv
+++ b/erpnext/translations/id.csv
@@ -3,12 +3,12 @@
 DocType: Patient,Divorced,Bercerai
 DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Izinkan Stok Barang yang sama untuk ditambahkan beberapa kali dalam suatu transaksi
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Batal Bahan Kunjungan {0} sebelum membatalkan Garansi Klaim ini
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +19,Consumer Products,Produk Pelanggan
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Produk Pelanggan
 DocType: Purchase Receipt,Subscription Detail,Detail Langganan
 DocType: Supplier Scorecard,Notify Supplier,Beritahu Pemasok
 DocType: Item,Customer Items,Produk Pelanggan
 DocType: Project,Costing and Billing,Biaya dan Penagihan
-apps/erpnext/erpnext/accounts/doctype/account/account.py +52,Account {0}: Parent account {1} can not be a ledger,Akun {0}: akun Induk {1} tidak dapat berupa buku besar
+apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Akun {0}: akun Induk {1} tidak dapat berupa buku besar
 DocType: Item,Publish Item to hub.erpnext.com,Publikasikan Item untuk hub.erpnext.com
 apps/erpnext/erpnext/config/setup.py +88,Email Notifications,Notifikasi Email
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,Evaluasi
@@ -20,10 +20,9 @@
 DocType: Restaurant Order Entry,Click Enter To Add,Klik Enter To Add
 DocType: Employee,Rented,Sewaan
 DocType: Purchase Order,PO-,po
-DocType: POS Profile,Applicable for User,Berlaku untuk Pengguna
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +196,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Berhenti Order Produksi tidak dapat dibatalkan, unstop terlebih dahulu untuk membatalkan"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Berhenti Order Produksi tidak dapat dibatalkan, unstop terlebih dahulu untuk membatalkan"
 DocType: Vehicle Service,Mileage,Jarak tempuh
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +220,Do you really want to scrap this asset?,Apakah Anda benar-benar ingin membatalkan aset ini?
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +240,Do you really want to scrap this asset?,Apakah Anda benar-benar ingin membatalkan aset ini?
 DocType: Drug Prescription,Update Schedule,Update Jadwal
 apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Pilih Default Pemasok
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Mata Uang diperlukan untuk Daftar Harga {0}
@@ -32,8 +31,8 @@
 DocType: Patient Appointment,Check availability,Cek ketersediaan
 DocType: Job Applicant,Job Applicant,Pemohon Kerja
 apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Hal ini didasarkan pada transaksi terhadap Pemasok ini. Lihat timeline di bawah untuk rincian
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +34,Legal,Hukum
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Actual type tax cannot be included in Item rate in row {0},Jenis pajak aktual tidak dapat dimasukkan dalam tarif di baris {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Hukum
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Jenis pajak aktual tidak dapat dimasukkan dalam tarif di baris {0}
 DocType: Bank Guarantee,Customer,Pelanggan
 DocType: Purchase Receipt Item,Required By,Diperlukan Oleh
 DocType: Delivery Note,Return Against Delivery Note,Retur Terhadap Nota Pengiriman
@@ -41,79 +40,91 @@
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Kurs harus sama dengan {0} {1} ({2})
 DocType: Sales Invoice,Customer Name,Nama Pelanggan
 DocType: Vehicle,Natural Gas,Gas alam
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +120,Bank account cannot be named as {0},Rekening bank tidak dapat namakan sebagai {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Rekening bank tidak dapat namakan sebagai {0}
 DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Kepala (atau kelompok) terhadap yang Entri Akuntansi dibuat dan saldo dipertahankan.
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Posisi untuk {0} tidak bisa kurang dari nol ({1})
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +357,There are no submitted Salary Slips to process.,Tidak ada slip Saldo yang diajukan untuk diproses.
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Tidak ada slip Saldo yang diajukan untuk diproses.
 DocType: Manufacturing Settings,Default 10 mins,Standar 10 menit
 DocType: Leave Type,Leave Type Name,Nama Tipe Cuti
 apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Tampilkan terbuka
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Hal ini diperlukan untuk mengambil tindakan ini hari ini sendiri untuk berulang di atas
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Series Berhasil Diupdate
 apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Periksa
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +175,Accural Journal Entry Submitted,Accural Journal Entri Dikirim
 DocType: Pricing Rule,Apply On,Terapkan Pada
 DocType: Item Price,Multiple Item prices.,Multiple Item harga.
 ,Purchase Order Items To Be Received,Order Pembelian Stok Barang Akan Diterima
 DocType: SMS Center,All Supplier Contact,Kontak semua Supplier
 DocType: Support Settings,Support Settings,Pengaturan dukungan
-apps/erpnext/erpnext/projects/doctype/project/project.py +70,Expected End Date can not be less than Expected Start Date,Diharapkan Tanggal Berakhir tidak bisa kurang dari yang diharapkan Tanggal Mulai
+apps/erpnext/erpnext/projects/doctype/project/project.py +72,Expected End Date can not be less than Expected Start Date,Diharapkan Tanggal Berakhir tidak bisa kurang dari yang diharapkan Tanggal Mulai
 apps/erpnext/erpnext/utilities/transaction_base.py +110,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Tingkat harus sama dengan {1}: {2} ({3} / {4})
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,Aplikasi Cuti Baru
 ,Batch Item Expiry Status,Status Kadaluarsa Persediaan Batch
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +180,Bank Draft,Bank Draft
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Bank Draft
+DocType: Membership,membership validaty section,bagian keanggotaan validitas
 DocType: Mode of Payment Account,Mode of Payment Account,Mode Akun Pembayaran Rekening
 DocType: Consultation,Consultation,Konsultasi
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +21,Sales and Returns,Penjualan dan Pengembalian
+DocType: Accounts Settings,Show Payment Schedule in Print,Tampilkan Jadwal Pembayaran di Cetak
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Penjualan dan Pengembalian
 apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Tampilkan Varian
 DocType: Academic Term,Academic Term,Jangka akademik
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Bahan
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +670,Quantity,Kuantitas
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Tabel account tidak boleh kosong.
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Membuat website
+DocType: Opening Invoice Creation Tool Item,Quantity,Kuantitas
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +544,Accounts table cannot be blank.,Tabel account tidak boleh kosong.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Kredit (Kewajiban)
 DocType: Employee Education,Year of Passing,Tahun Berjalan
 DocType: Item,Country of Origin,Negara Asal
+DocType: Soil Texture,Soil Texture Criteria,Kriteria Tekstur Tanah
 apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,Dalam Persediaan
+apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Rincian Kontak Utama
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,terbuka Isu
 DocType: Production Plan Item,Production Plan Item,Rencana Produksi Stok Barang
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,User {0} is already assigned to Employee {1},Pengguna {0} sudah ditugaskan untuk Karyawan {1}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Pengguna {0} sudah ditugaskan untuk Karyawan {1}
 DocType: Lab Test Groups,Add new line,Tambahkan baris baru
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +31,Health Care,Kesehatan
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Kesehatan
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Keterlambatan pembayaran (Hari)
+DocType: Payment Terms Template Detail,Payment Terms Template Detail,Rincian Syarat Pembayaran
 DocType: Lab Prescription,Lab Prescription,Resep Lab
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +185,Sort by Price,Urutkan berdasarkan harga
 apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Beban layanan
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +888,Serial Number: {0} is already referenced in Sales Invoice: {1},Nomor Seri: {0} sudah dirujuk dalam Faktur Penjualan: {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +849,Invoice,Faktur
-DocType: Maintenance Schedule Item,Periodicity,Periode
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +893,Serial Number: {0} is already referenced in Sales Invoice: {1},Nomor Seri: {0} sudah dirujuk dalam Faktur Penjualan: {1}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Invoice,Faktur
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +109,Make Retention Stock Entry,Buat Entri Stok Retensi
+DocType: Purchase Invoice Item,Item Weight Details,Rincian Berat Item
+DocType: Asset Maintenance Log,Periodicity,Periode
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Tahun fiskal {0} diperlukan
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +21,Defense,Pertahanan
+DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Jarak minimum antara deretan tanaman untuk pertumbuhan optimum
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Pertahanan
 DocType: Salary Component,Abbr,Singkatan
 DocType: Appraisal Goal,Score (0-5),Skor (0-5)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225,Row {0}: {1} {2} does not match with {3},Baris {0}: {1} {2} tidak cocok dengan {3}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +223,Row {0}: {1} {2} does not match with {3},Baris {0}: {1} {2} tidak cocok dengan {3}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +75,Row # {0}:,Row # {0}:
 DocType: Timesheet,Total Costing Amount,Jumlah Total Biaya
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Pelanggan&gt; Grup Pelanggan&gt; Wilayah
 DocType: Delivery Note,Vehicle No,Nomor Kendaraan
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +160,Please select Price List,Silakan pilih Daftar Harga
 DocType: Accounts Settings,Currency Exchange Settings,Pengaturan Pertukaran Mata Uang
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Dokumen Pembayaran diperlukan untuk menyelesaikan trasaction yang
 DocType: Production Order Operation,Work In Progress,Pekerjaan dalam proses
-apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +13,Please select date,Silakan pilih tanggal
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Silakan pilih tanggal
 DocType: Employee,Holiday List,Daftar Hari Libur
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +123,Accountant,Akuntan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Akuntan
 DocType: Hub Settings,Selling Price List,Daftar Harga Jual
 DocType: Patient,Tobacco Current Use,Penggunaan Saat Ini Tembakau
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +21,Selling Rate,Tingkat penjualan
 DocType: Cost Center,Stock User,Pengguna Persediaan
+DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
 DocType: Company,Phone No,No Telepon yang
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +50,Course Schedules created:,Jadwal Kursus dibuat:
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +237,New {0}: #{1},Baru {0}: # {1}
+DocType: Delivery Trip,Initial Email Notification Sent,Pemberitahuan email awal terkirim
 ,Sales Partners Commission,Komisi Mitra Penjualan
+DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
 DocType: Purchase Invoice,Rounding Adjustment,Penyesuaian Pembulatan
 apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Singkatan tidak boleh melebihi 5 karakter
 DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Jadwal Waktu Slot Dokter
 DocType: Payment Request,Payment Request,Permintaan pembayaran
 DocType: Asset,Value After Depreciation,Nilai Setelah Penyusutan
-DocType: Employee,O+,O +
+DocType: Student,O+,O +
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,terkait
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,tanggal kehadiran tidak bisa kurang dari tanggal bergabung karyawan
 DocType: Grading Scale,Grading Scale Name,Skala Grading Nama
@@ -126,149 +137,154 @@
 apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} tidak dalam Tahun Anggaran aktif.
 DocType: Packed Item,Parent Detail docname,Induk Detil docname
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Referensi: {0}, Kode Item: {1} dan Pelanggan: {2}"
-apps/erpnext/erpnext/utilities/user_progress.py +125,Kg,Kg
+apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,Kg
 apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Lowongan untuk Pekerjaan.
-apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +147,{0} Result submittted,{0} Hasil terkirim
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +103,BOM is not specified for subcontracting item {0} at row {1},BOM tidak ditentukan untuk item subkontrak {0} pada baris {1}
+apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Hasil terkirim
 DocType: Item Attribute,Increment,Kenaikan
 apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +61,Timespan,Rentang waktu
 apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Pilih Gudang ...
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +6,Advertising,Periklanan (Promosi)
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Periklanan (Promosi)
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Perusahaan yang sama dimasukkan lebih dari sekali
 DocType: Patient,Married,Menikah
 apps/erpnext/erpnext/accounts/party.py +44,Not permitted for {0},Tidak diizinkan untuk {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +568,Get items from,Mendapatkan Stok Barang-Stok Barang dari
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +457,Stock cannot be updated against Delivery Note {0},Persediaan tidak dapat diperbarui terhadap Nota Pengiriman {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Mendapatkan Stok Barang-Stok Barang dari
+DocType: Price List,Price Not UOM Dependant,Harga UOM Tidak Tergantung
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +461,Stock cannot be updated against Delivery Note {0},Persediaan tidak dapat diperbarui terhadap Nota Pengiriman {0}
 apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produk {0}
 apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Tidak ada item yang terdaftar
+DocType: Asset Repair,Error Description,Deskripsi kesalahan
 DocType: Payment Reconciliation,Reconcile,Rekonsiliasi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,Toko Kelontongan
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Toko Kelontongan
 DocType: Quality Inspection Reading,Reading 1,Membaca 1
-DocType: Process Payroll,Make Bank Entry,Buat Entri Bank
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +40,Pension Funds,Dana pensiun
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Berikutnya Penyusutan Tanggal tidak boleh sebelum Tanggal Pembelian
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Dana pensiun
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Berikutnya Penyusutan Tanggal tidak boleh sebelum Tanggal Pembelian
+DocType: Crop,Perennial,Abadi
 DocType: Consultation,Consultation Date,Tanggal Konsultasi
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +131,Product listing and discovery for ERPNext users,Daftar produk dan penemuan untuk pengguna ERPNext
 DocType: SMS Center,All Sales Person,Semua Salesmen
 DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Distribusi Bulanan ** membantu Anda mendistribusikan Anggaran / Target di antara bulan-bulan jika bisnis Anda memiliki musim.
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1727,Not items found,Tidak item yang ditemukan
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1742,Not items found,Tidak item yang ditemukan
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Struktur Gaji Hilang
 DocType: Lead,Person Name,Nama orang
 DocType: Sales Invoice Item,Sales Invoice Item,Faktur Penjualan Stok Barang
 DocType: Account,Credit,Kredit
 DocType: POS Profile,Write Off Cost Center,Write Off Biaya Pusat
-apps/erpnext/erpnext/public/js/setup_wizard.js +114,"e.g. ""Primary School"" or ""University""",misalnya &quot;Sekolah Dasar&quot; atau &quot;Universitas&quot;
-apps/erpnext/erpnext/config/stock.py +32,Stock Reports,Laporan Persediaan
+apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",misalnya &quot;Sekolah Dasar&quot; atau &quot;Universitas&quot;
+apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Laporan Persediaan
 DocType: Warehouse,Warehouse Detail,Detail Gudang
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +164,Credit limit has been crossed for customer {0} {1}/{2},Batas kredit telah terlampaui untuk Pelanggan {0} {1}/{2}
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Jangka Tanggal Akhir tidak bisa lebih lambat dari Akhir Tahun Tanggal Tahun Akademik yang istilah terkait (Tahun Akademik {}). Perbaiki tanggal dan coba lagi.
-apps/erpnext/erpnext/stock/doctype/item/item.py +479,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Aset Tetap"" tidak dapat tidak dicentang, karena ada data Asset terhadap barang"
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +192,Credit limit has been crossed for customer {0} {1}/{2},Batas kredit telah terlampaui untuk Pelanggan {0} {1}/{2}
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Jangka Tanggal Akhir tidak bisa lebih lambat dari Akhir Tahun Tanggal Tahun Akademik yang istilah terkait (Tahun Akademik {}). Perbaiki tanggal dan coba lagi.
+apps/erpnext/erpnext/stock/doctype/item/item.py +258,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Aset Tetap"" tidak dapat tidak dicentang, karena ada data Asset terhadap barang"
+DocType: Delivery Trip,Departure Time,Waktu keberangkatan
 DocType: Vehicle Service,Brake Oil,Minyak Rem
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Pelanggan&gt; Grup Pelanggan&gt; Wilayah
 DocType: Tax Rule,Tax Type,Jenis pajak
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +555,Taxable Amount,Jumlah Kena Pajak
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +561,Taxable Amount,Jumlah Kena Pajak
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Anda tidak diizinkan menambah atau memperbarui entri sebelum {0}
 DocType: BOM,Item Image (if not slideshow),Gambar Stok Barang (jika tidak slideshow)
 DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Tarif per Jam / 60) * Masa Beroperasi Sebenarnya
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1050,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Baris # {0}: Jenis Dokumen Referensi harus menjadi salah satu Klaim Biaya atau Entri Jurnal
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +917,Select BOM,Pilih BOM
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Baris # {0}: Jenis Dokumen Referensi harus menjadi salah satu Klaim Biaya atau Entri Jurnal
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +964,Select BOM,Pilih BOM
 DocType: SMS Log,SMS Log,SMS Log
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Biaya Produk Terkirim
+apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Mengelola jumlah uang muka yang diberikan kepada Karyawan
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Liburan di {0} bukan antara Dari Tanggal dan To Date
 DocType: Student Log,Student Log,Mahasiswa Log
 DocType: Quality Inspection,Get Specification Details,Dapatkan Spesifikasi Detail
 apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Template dari klasemen pemasok.
 DocType: Lead,Interested,Tertarik
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +171,Opening,Pembukaan
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +28,From {0} to {1},Dari {0} ke {1}
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +219,Opening,Pembukaan
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +29,From {0} to {1},Dari {0} ke {1}
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Gagal menyetorkan pajak
 DocType: Item,Copy From Item Group,Salin Dari Grup Stok Barang
+DocType: Delivery Trip,Delivery Notification,Pemberitahuan pengiriman
 DocType: Journal Entry,Opening Entry,Entri Pembukaan
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Akun Pay Hanya
 DocType: Employee Loan,Repay Over Number of Periods,Membayar Lebih dari Jumlah Periode
 DocType: Stock Entry,Additional Costs,Biaya-biaya tambahan
-apps/erpnext/erpnext/accounts/doctype/account/account.py +141,Account with existing transaction can not be converted to group.,Akun dengan transaksi yang ada tidak dapat dikonversi ke grup.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +140,Account with existing transaction can not be converted to group.,Akun dengan transaksi yang ada tidak dapat dikonversi ke grup.
 DocType: Lead,Product Enquiry,Produk Enquiry
-DocType: Academic Term,Schools,sekolah
-DocType: School Settings,Validate Batch for Students in Student Group,Validasi Batch untuk Siswa di Kelompok Pelajar
+DocType: Education Settings,Validate Batch for Students in Student Group,Validasi Batch untuk Siswa di Kelompok Pelajar
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Tidak ada cuti record yang ditemukan untuk karyawan {0} untuk {1}
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Silahkan masukkan perusahaan terlebih dahulu
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +358,Please select Company first,Silakan pilih Perusahaan terlebih dahulu
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Company first,Silakan pilih Perusahaan terlebih dahulu
 DocType: Employee Education,Under Graduate,Sarjana
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Sasaran On
 DocType: BOM,Total Cost,Total Biaya
+DocType: Soil Analysis,Ca/K,Ca / K
 DocType: Journal Entry Account,Employee Loan,Pinjaman karyawan
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +108,Activity Log:,Log Aktivitas:
 DocType: Fee Schedule,Send Payment Request Email,Kirim Permintaan Pembayaran Email
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +256,Item {0} does not exist in the system or has expired,Item {0} tidak ada dalam sistem atau telah berakhir
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +44,Real Estate,Real Estate
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +259,Item {0} does not exist in the system or has expired,Item {0} tidak ada dalam sistem atau telah berakhir
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Real Estate
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Laporan Rekening
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +41,Pharmaceuticals,Farmasi
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Farmasi
 DocType: Purchase Invoice Item,Is Fixed Asset,Apakah Aset Tetap
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +234,"Available qty is {0}, you need {1}","Tersedia qty adalah {0}, Anda perlu {1}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +251,"Available qty is {0}, you need {1}","Tersedia qty adalah {0}, Anda perlu {1}"
 DocType: Expense Claim Detail,Claim Amount,Nilai Klaim
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +51,Duplicate customer group found in the cutomer group table,kelompok pelanggan duplikat ditemukan di tabel kelompok cutomer
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,kelompok pelanggan duplikat ditemukan di tabel kelompok cutomer
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Supplier Type / Supplier
 DocType: Naming Series,Prefix,Awalan
 apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Lokasi acara
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +64,Consumable,Consumable
-DocType: Employee,B-,B-
-DocType: Upload Attendance,Import Log,Impor Log
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Consumable
+DocType: Student,B-,B-
 DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Tarik Bahan Permintaan jenis Industri berdasarkan kriteria di atas
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +100,Successfully unregistered.,Berhasil tidak terdaftar
-DocType: Training Result Employee,Grade,Kelas
+DocType: Assessment Result,Grade,Kelas
 DocType: Restaurant Table,No of Seats,Tidak ada tempat duduk
 DocType: Subscription,"To add dynamic subject, use jinja tags like
 
 <div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Untuk menambahkan subjek dinamis, gunakan tag jinja seperti <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
 DocType: Sales Invoice Item,Delivered By Supplier,Terkirim Oleh Supplier
+DocType: Asset Maintenance Task,Asset Maintenance Task,Tugas Pemeliharaan Aset
 DocType: SMS Center,All Contact,Semua Kontak
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +905,Production Order already created for all items with BOM,Pesanan produksi sudah dibuat untuk semua item dengan BOM
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +220,Annual Salary,Gaji Tahunan
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +952,Production Order already created for all items with BOM,Pesanan produksi sudah dibuat untuk semua item dengan BOM
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +230,Annual Salary,Gaji Tahunan
 DocType: Daily Work Summary,Daily Work Summary,Ringkasan Pekerjaan sehari-hari
 DocType: Period Closing Voucher,Closing Fiscal Year,Penutup Tahun Anggaran
-apps/erpnext/erpnext/accounts/party.py +368,{0} {1} is frozen,{0} {1} dibekukan
-apps/erpnext/erpnext/setup/doctype/company/company.py +132,Please select Existing Company for creating Chart of Accounts,Silakan pilih Perusahaan yang ada untuk menciptakan Chart of Account
+apps/erpnext/erpnext/accounts/party.py +380,{0} {1} is frozen,{0} {1} dibekukan
+apps/erpnext/erpnext/setup/doctype/company/company.py +129,Please select Existing Company for creating Chart of Accounts,Silakan pilih Perusahaan yang ada untuk menciptakan Chart of Account
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Beban Persediaan
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +96,Select Target Warehouse,Pilih Target Warehouse
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Pilih Target Warehouse
 apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Silahkan masukkan Kontak Email Utama
-DocType: Program Enrollment,School Bus,Bus sekolah
 DocType: Journal Entry,Contra Entry,Contra Entri
 DocType: Journal Entry Account,Credit in Company Currency,Kredit di Perusahaan Mata
 DocType: Lab Test UOM,Lab Test UOM,Uji Lab UOM
 DocType: Delivery Note,Installation Status,Status Instalasi
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
 					<br>Absent: {1}",Apakah Anda ingin memperbarui kehadiran? <br> Hadir: {0} \ <br> Absen: {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +325,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Jumlah Diterima + Ditolak harus sama dengan jumlah yang diterima untuk Item {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +326,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Jumlah Diterima + Ditolak harus sama dengan jumlah yang diterima untuk Item {0}
 DocType: Request for Quotation,RFQ-,RFQ-
 DocType: Item,Supply Raw Materials for Purchase,Bahan pasokan baku untuk Pembelian
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +149,At least one mode of payment is required for POS invoice.,Setidaknya satu cara pembayaran diperlukan untuk POS faktur.
+DocType: Agriculture Analysis Criteria,Fertilizer,Pupuk
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +150,At least one mode of payment is required for POS invoice.,Setidaknya satu cara pembayaran diperlukan untuk POS faktur.
 DocType: Products Settings,Show Products as a List,Tampilkan Produk sebagai sebuah Daftar
-DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
-All dates and employee combination in the selected period will come in the template, with existing attendance records","Unduh Template, isi data yang sesuai dan lampirkan file yang sudah dimodifikasi. Semua kombinasi tanggal dan karyawan dalam periode yang dipilih akan masuk dalam template, dengan catatan kehadiran yang ada"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +482,Item {0} is not active or end of life has been reached,Item {0} tidak aktif atau akhir hidup telah tercapai
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +507,Item {0} is not active or end of life has been reached,Item {0} tidak aktif atau akhir hidup telah tercapai
 DocType: Student Admission Program,Minimum Age,Usia Minimum
-apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Basic Mathematics,Contoh: Matematika Dasar
-apps/erpnext/erpnext/controllers/accounts_controller.py +657,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Untuk mencakup pajak berturut-turut {0} di tingkat Stok Barang, pajak dalam baris {1} juga harus disertakan"
-apps/erpnext/erpnext/config/hr.py +218,Settings for HR Module,Pengaturan untuk modul HR
+apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Contoh: Matematika Dasar
+apps/erpnext/erpnext/controllers/accounts_controller.py +769,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Untuk mencakup pajak berturut-turut {0} di tingkat Stok Barang, pajak dalam baris {1} juga harus disertakan"
+apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Pengaturan untuk modul HR
 DocType: SMS Center,SMS Center,SMS Center
 DocType: Sales Invoice,Change Amount,perubahan Jumlah
 DocType: BOM Update Tool,New BOM,BOM Baru
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +117,Please enter Delivery Date,Harap masukkan Tanggal Pengiriman
+DocType: Driver,Driving License Categories,Kategori Lisensi Mengemudi
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Harap masukkan Tanggal Pengiriman
 DocType: Depreciation Schedule,Make Depreciation Entry,Membuat Penyusutan Masuk
 DocType: Appraisal Template Goal,KRA,KRA
 DocType: Lead,Request Type,Permintaan Type
 apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,membuat Karyawan
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +14,Broadcasting,Penyiaran
-apps/erpnext/erpnext/config/accounts.py +321,Setup mode of POS (Online / Offline),Modus setup POS (Online / Offline)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +187,Execution,Eksekusi
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Penyiaran
+apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Modus setup POS (Online / Offline)
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,Eksekusi
 apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Rincian operasi yang dilakukan.
-DocType: Serial No,Maintenance Status,Status pemeliharaan
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Pemasok diperlukan terhadap akun Hutang {2}
+DocType: Asset Maintenance Log,Maintenance Status,Status pemeliharaan
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Rincian Keanggotaan
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Pemasok diperlukan untuk akun Hutang {2}
 apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Item dan Harga
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Jumlah jam: {0}
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Dari tanggal harus dalam Tahun Anggaran. Dengan asumsi Dari Tanggal = {0}
 DocType: Drug Prescription,Interval,Selang
-DocType: Customer,Individual,Individu
-DocType: Interest,Academics User,Pengguna Akademis
+DocType: Grant Application,Individual,Individu
+DocType: Academic Term,Academics User,Pengguna Akademis
 DocType: Cheque Print Template,Amount In Figure,Jumlah Dalam Gambar
 DocType: Employee Loan Application,Loan Info,Info kredit
 apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Rencana kunjungan pemeliharaan.
@@ -281,17 +297,19 @@
 apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Harga List harus berlaku untuk Membeli atau Jual
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Tanggal instalasi tidak bisa sebelum tanggal pengiriman untuk Item {0}
 DocType: Pricing Rule,Discount on Price List Rate (%),Diskon Harga Daftar Rate (%)
-apps/erpnext/erpnext/healthcare/setup.py +214,Biochemistry,Biokimia
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Item Template
+apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biokimia
 DocType: Offer Letter,Select Terms and Conditions,Pilih Syarat dan Ketentuan
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +60,Out Value,out Nilai
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,out Nilai
 DocType: Production Planning Tool,Sales Orders,Order Penjualan
 DocType: Purchase Taxes and Charges,Valuation,Valuation
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +373,Set as Default,Set sebagai Default
 ,Purchase Order Trends,Trend Order Pembelian
 apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Pergi ke pelanggan
 apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Permintaan untuk kutipan dapat diakses dengan mengklik link berikut
 apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Alokasi cuti untuk tahun berjalan.
 DocType: SG Creation Tool Course,SG Creation Tool Course,SG Penciptaan Alat Course
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +236,Insufficient Stock,Persediaan tidak cukup
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,Insufficient Stock,Persediaan tidak cukup
 DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Nonaktifkan Perencanaan Kapasitas dan Waktu Pelacakan
 DocType: Email Digest,New Sales Orders,Penjualan New Orders
 DocType: Bank Guarantee,Bank Account,Rekening Bank
@@ -299,67 +317,69 @@
 apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Anda tidak bisa menghapus Jenis Proyek 'External'
 DocType: Employee,Create User,Buat pengguna
 DocType: Selling Settings,Default Territory,Wilayah Standar
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Televisi
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televisi
 DocType: Production Order Operation,Updated via 'Time Log',Diperbarui melalui 'Time Log'
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +427,Advance amount cannot be greater than {0} {1},Jumlah muka tidak dapat lebih besar dari {0} {1}
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +428,Advance amount cannot be greater than {0} {1},Jumlah muka tidak dapat lebih besar dari {0} {1}
 DocType: Naming Series,Series List for this Transaction,Daftar Series Transaksi ini
 DocType: Company,Enable Perpetual Inventory,Aktifkan Inventaris Abadi
 DocType: Company,Default Payroll Payable Account,Default Payroll Hutang Akun
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +51,Update Email Group,Update Email Kelompok
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Update Email Kelompok
 DocType: Sales Invoice,Is Opening Entry,Entri Pembuka?
 DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Jika tidak dicentang, item tersebut tidak akan muncul dalam Sales Invoice, namun dapat digunakan dalam pembuatan uji kelompok."
 DocType: Customer Group,Mention if non-standard receivable account applicable,Sebutkan jika akun non-standar piutang yang berlaku
 DocType: Course Schedule,Instructor Name,instruktur Nama
 DocType: Supplier Scorecard,Criteria Setup,Setup kriteria
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +179,For Warehouse is required before Submit,Untuk Gudang diperlukan sebelum Submit
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,For Warehouse is required before Submit,Untuk Gudang diperlukan sebelum Submit
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Diterima pada
 DocType: Sales Partner,Reseller,Reseller
 DocType: Codification Table,Medical Code,Kode medis
 DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Jika dicentang, akan mencakup barang non-persediaan di Permintaan Material."
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Pilih Perusahaan
 DocType: Delivery Note Item,Against Sales Invoice Item,Terhadap Barang di Faktur Penjualan
+DocType: Agriculture Analysis Criteria,Linked Doctype,Linked Doctype
 ,Production Orders in Progress,Order produksi dalam Proses
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Kas Bersih dari Pendanaan
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2313,"LocalStorage is full , did not save","LocalStorage penuh, tidak menyimpan"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2332,"LocalStorage is full , did not save","LocalStorage penuh, tidak menyimpan"
 DocType: Lead,Address & Contact,Alamat & Kontak
 DocType: Leave Allocation,Add unused leaves from previous allocations,Tambahkan 'cuti tak terpakai' dari alokasi sebelumnya
 DocType: Sales Partner,Partner website,situs mitra
 DocType: Restaurant Order Entry,Add Item,Tambahkan Barang
 DocType: Lab Test,Custom Result,Hasil Kustom
-apps/erpnext/erpnext/utilities/user_progress.py +71,Contact Name,Nama Kontak
+DocType: Delivery Stop,Contact Name,Nama Kontak
 DocType: Course Assessment Criteria,Course Assessment Criteria,Kriteria Penilaian saja
-DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Membuat Slip gaji untuk kriteria yang disebutkan di atas.
 DocType: POS Customer Group,POS Customer Group,POS Pelanggan Grup
+DocType: Land Unit,Land Unit describing various land assets,Unit Tanah yang menggambarkan berbagai aset pertanahan
 DocType: Cheque Print Template,Line spacing for amount in words,spasi untuk jumlah kata
 DocType: Vehicle,Additional Details,Rincian Tambahan
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Rencana Penilaian:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Rencana Penilaian:
 apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Tidak diberikan deskripsi
 apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Form Permintaan pembelian.
 DocType: Lab Test,Submitted Date,Tanggal dikirim
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Hal ini didasarkan pada Lembar Waktu diciptakan terhadap proyek ini
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +390,Net Pay cannot be less than 0,Pay bersih yang belum bisa kurang dari 0
+DocType: Payment Term,Credit Months,Bulan kredit
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Pay bersih yang belum bisa kurang dari 0
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Untuk berhenti mengirim pemberitahuan kesalahan berulang dari sistem, kami telah memeriksa kolom Nonaktif dalam langganan"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Hanya dipilih Cuti Approver dapat mengirimkan Aplikasi Cuti ini
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Relieving Date must be greater than Date of Joining,Menghilangkan Tanggal harus lebih besar dari Tanggal Bergabung
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +228,Leaves per Year,cuti per Tahun
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,Baris {0}: Silakan periksa 'Apakah Muka' terhadap Rekening {1} jika ini adalah sebuah entri muka.
-apps/erpnext/erpnext/stock/utils.py +212,Warehouse {0} does not belong to company {1},Gudang {0} bukan milik perusahaan {1}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,Menghilangkan Tanggal harus lebih besar dari Tanggal Bergabung
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Leaves per Year,cuti per Tahun
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +128,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,Baris {0}: Silakan periksa 'Apakah Muka' terhadap Rekening {1} jika ini adalah sebuah entri muka.
+apps/erpnext/erpnext/stock/utils.py +217,Warehouse {0} does not belong to company {1},Gudang {0} bukan milik perusahaan {1}
 DocType: Email Digest,Profit & Loss,Rugi laba
-apps/erpnext/erpnext/utilities/user_progress.py +126,Litre,Liter
+apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Liter
 DocType: Task,Total Costing Amount (via Time Sheet),Total Costing Jumlah (via Waktu Lembar)
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.py +63,Please setup Students under Student Groups,Tolong atur Siswa di Kelompok Siswa
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Tolong atur Siswa di Kelompok Siswa
 DocType: Item Website Specification,Item Website Specification,Item Situs Spesifikasi
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +477,Leave Blocked,Cuti Diblokir
-apps/erpnext/erpnext/stock/doctype/item/item.py +723,Item {0} has reached its end of life on {1},Item {0} telah mencapai akhir hidupnya pada {1}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +88,Bank Entries,Entri Bank
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +119,Annual,Tahunan
+apps/erpnext/erpnext/stock/doctype/item/item.py +709,Item {0} has reached its end of life on {1},Item {0} telah mencapai akhir hidupnya pada {1}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +99,Bank Entries,Entri Bank
+DocType: Crop,Annual,Tahunan
 DocType: Stock Reconciliation Item,Stock Reconciliation Item,Barang Rekonsiliasi Persediaan
 DocType: Stock Entry,Sales Invoice No,Nomor Faktur Penjualan
 DocType: Material Request Item,Min Order Qty,Min Order Qty
 DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Kursus Grup Pelajar Penciptaan Alat
 DocType: Lead,Do Not Contact,Jangan Hubungi
-apps/erpnext/erpnext/utilities/user_progress.py +189,People who teach at your organisation,Orang-orang yang mengajar di organisasi Anda
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +131,Software Developer,Software Developer
+apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,Orang-orang yang mengajar di organisasi Anda
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Software Developer
 DocType: Item,Minimum Order Qty,Minimum Order Qty
 DocType: Pricing Rule,Supplier Type,Supplier Type
 DocType: Course Scheduling Tool,Course Start Date,Tentu saja Tanggal Mulai
@@ -368,58 +388,64 @@
 DocType: Item,Publish in Hub,Publikasikan di Hub
 DocType: Student Admission,Student Admission,Mahasiswa Pendaftaran
 ,Terretory,Terretory
-apps/erpnext/erpnext/stock/doctype/item/item.py +743,Item {0} is cancelled,Item {0} dibatalkan
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +923,Material Request,Permintaan Material
+apps/erpnext/erpnext/stock/doctype/item/item.py +729,Item {0} is cancelled,Item {0} dibatalkan
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Material Request,Permintaan Material
 DocType: Bank Reconciliation,Update Clearance Date,Perbarui Izin Tanggal
 DocType: Item,Purchase Details,Rincian pembelian
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Item {0} tidak ditemukan dalam &#39;Bahan Baku Disediakan&#39; tabel dalam Purchase Order {1}
-DocType: Patient Relation,Relation,Hubungan
-DocType: Shipping Rule,Worldwide Shipping,Pengiriman seluruh dunia
-DocType: Patient Relation,Mother,Ibu
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +382,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Item {0} tidak ditemukan dalam &#39;Bahan Baku Disediakan&#39; tabel dalam Purchase Order {1}
+DocType: Salary Slip,Total Principal Amount,Jumlah Pokok Jumlah
+DocType: Student Guardian,Relation,Hubungan
+DocType: Student Guardian,Mother,Ibu
 DocType: Restaurant Reservation,Reservation End Time,Reservasi Akhir Waktu
+DocType: Crop,Biennial,Dua tahunan
 apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Pesanan terkonfirmasi dari Pelanggan.
 DocType: Purchase Receipt Item,Rejected Quantity,Kuantitas Ditolak
-apps/erpnext/erpnext/schools/doctype/fees/fees.py +80,Payment request {0} created,Permintaan pembayaran {0} dibuat
-apps/erpnext/erpnext/healthcare/setup.py +254,Low Sensitivity,Sensitivitas rendah
+apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Permintaan pembayaran {0} dibuat
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Pesanan Terbuka
+apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Sensitivitas rendah
 DocType: Notification Control,Notification Control,Pemberitahuan Kontrol
 apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Harap konfirmasi setelah Anda menyelesaikan pelatihan Anda
 DocType: Lead,Suggestions,Saran
 DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Menetapkan anggaran Group-bijaksana Stok Barang di Wilayah ini. Anda juga bisa memasukkan musiman dengan menetapkan Distribusi.
+DocType: Payment Term,Payment Term Name,Nama Istilah Pembayaran
 DocType: Healthcare Settings,Create documents for sample collection,Buat dokumen untuk koleksi sampel
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Pembayaran terhadap {0} {1} tidak dapat lebih besar dari Posisi Jumlah {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +274,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Pembayaran terhadap {0} {1} tidak dapat lebih besar dari Posisi Jumlah {2}
 DocType: Supplier,Address HTML,Alamat HTML
 DocType: Lead,Mobile No.,Nomor Ponsel
 DocType: Maintenance Schedule,Generate Schedule,Hasilkan Jadwal
 DocType: Purchase Invoice Item,Expense Head,Akun Kepala Biaya
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +146,Please select Charge Type first,Silakan pilih Mengisi Tipe terlebih dahulu
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +163,Please select Charge Type first,Silakan pilih Mengisi Tipe terlebih dahulu
+DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Anda dapat menentukan semua tugas yang perlu dilakukan untuk tanaman ini di sini. Bidang hari digunakan untuk menyebutkan hari dimana tugas tersebut perlu dilakukan, 1 menjadi hari pertama, dll."
 DocType: Student Group Student,Student Group Student,Mahasiswa Grup Pelajar
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Terbaru
+DocType: Asset Maintenance Task,2 Yearly,2 tahunan
+DocType: Education Settings,Education Settings,Pengaturan Pendidikan
 DocType: Vehicle Service,Inspection,Inspeksi
 DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
 DocType: Email Digest,New Quotations,Kutipan Baru
 DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Surel slip gaji ke karyawan berdasarkan surel utama yang dipilih dalam Karyawan
 DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,The Approver Cuti terlebih dahulu dalam daftar akan ditetapkan sebagai default Cuti Approver
 DocType: Tax Rule,Shipping County,Pengiriman County
-apps/erpnext/erpnext/config/desktop.py +159,Learn,Belajar
+apps/erpnext/erpnext/config/desktop.py +167,Learn,Belajar
 DocType: Asset,Next Depreciation Date,Berikutnya Penyusutan Tanggal
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Biaya Aktivitas Per Karyawan
 DocType: Accounts Settings,Settings for Accounts,Pengaturan Akun
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +663,Supplier Invoice No exists in Purchase Invoice {0},Pemasok Faktur ada ada di Purchase Invoice {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +667,Supplier Invoice No exists in Purchase Invoice {0},Pemasok Faktur ada ada di Purchase Invoice {0}
 apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Pengelolaan Tingkat Salesman
 DocType: Job Applicant,Cover Letter,Sampul surat
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Penghapusan Cek dan Deposito yang Jatuh Tempo
 DocType: Item,Synced With Hub,Disinkronkan Dengan Hub
-DocType: Vehicle,Fleet Manager,armada Manajer
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +517,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} tidak bisa menjadi negatif untuk item {2}
+DocType: Driver,Fleet Manager,armada Manajer
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} tidak bisa menjadi negatif untuk item {2}
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Kata Sandi Salah
 DocType: Item,Variant Of,Varian Of
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +367,Completed Qty can not be greater than 'Qty to Manufacture',Selesai Qty tidak dapat lebih besar dari 'Jumlah untuk Produksi'
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',Selesai Qty tidak dapat lebih besar dari 'Jumlah untuk Produksi'
 DocType: Period Closing Voucher,Closing Account Head,Penutupan Akun Kepala
 DocType: Employee,External Work History,Pengalaman Kerja Diluar
 DocType: Physician,Time per Appointment,Waktu per Penunjukan
 apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Referensi Kesalahan melingkar
 DocType: Appointment Type,Is Inpatient,Apakah rawat inap
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Nama Guardian1
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Nama Guardian1
 DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,Dalam Kata-kata (Ekspor) akan terlihat sekali Anda menyimpan Delivery Note.
 DocType: Cheque Print Template,Distance from left edge,Jarak dari tepi kiri
 apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} unit [{1}] (#Formulir/Barang/{1}) ditemukan di [{2}] (#Formulir/Gudang/{2})
@@ -428,20 +454,22 @@
 DocType: BOM Item,Rate & Amount,Tarif &amp; Jumlah
 apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Hal ini didasarkan pada transaksi terhadap Perusahaan ini. Lihat garis waktu di bawah untuk rinciannya
 DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Beritahu melalui Surel pada pembuatan Permintaan Material otomatis
-apps/erpnext/erpnext/healthcare/setup.py +258,Resistant,Tahan
+apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Tahan
 DocType: Journal Entry,Multi Currency,Multi Mata Uang
-DocType: Payment Reconciliation Invoice,Invoice Type,Tipe Faktur
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +865,Delivery Note,Nota Pengiriman
+DocType: Opening Invoice Creation Tool,Invoice Type,Tipe Faktur
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +933,Delivery Note,Nota Pengiriman
 DocType: Consultation,Encounter Impression,Tayangan Pertemuan
 apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Persiapan Pajak
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +131,Cost of Sold Asset,Biaya Asset Terjual
-apps/erpnext/erpnext/accounts/utils.py +345,Payment Entry has been modified after you pulled it. Please pull it again.,Entri pembayaran telah dimodifikasi setelah Anda menariknya. Silakan menariknya lagi.
-apps/erpnext/erpnext/stock/doctype/item/item.py +448,{0} entered twice in Item Tax,{0} dimasukan dua kali dalam Pajak Persediaan Barang
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Biaya Asset Terjual
+DocType: Volunteer,Morning,Pagi
+apps/erpnext/erpnext/accounts/utils.py +347,Payment Entry has been modified after you pulled it. Please pull it again.,Entri pembayaran telah dimodifikasi setelah Anda menariknya. Silakan menariknya lagi.
+apps/erpnext/erpnext/stock/doctype/item/item.py +464,{0} entered twice in Item Tax,{0} dimasukan dua kali dalam Pajak Barang
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Ringkasan untuk minggu ini dan kegiatan yang tertunda
 DocType: Student Applicant,Admitted,Diterima
 DocType: Workstation,Rent Cost,Biaya Sewa
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Jumlah Setelah Penyusutan
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Mendatang Kalender Acara
+apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Atribut varian
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,Silakan pilih bulan dan tahun
 DocType: Employee,Company Email,Email Perusahaan
 DocType: GL Entry,Debit Amount in Account Currency,Jumlah Debit di Akun Mata Uang
@@ -450,33 +478,35 @@
 apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Transaksi Bank / Cash terhadap partai atau untuk internal transfer
 DocType: Shipping Rule,Valid for Countries,Berlaku untuk Negara
 apps/erpnext/erpnext/stock/doctype/item/item.js +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,Stok Barang ini adalah Template dan tidak dapat digunakan dalam transaksi. Item atribut akan disalin ke dalam varian kecuali 'Tidak ada Copy' diatur
+DocType: Grant Application,Grant Application,Permohonan Hibah
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Total Order Diperhitungkan
-apps/erpnext/erpnext/config/hr.py +238,"Employee designation (e.g. CEO, Director etc.).","Penunjukan Karyawan (misalnya CEO, Direktur dll)."
+apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Penunjukan Karyawan (misalnya CEO, Direktur dll)."
 DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Tingkat di mana Mata Uang Pelanggan dikonversi ke mata uang dasar pelanggan
 DocType: Course Scheduling Tool,Course Scheduling Tool,Tentu saja Penjadwalan Perangkat
-apps/erpnext/erpnext/controllers/accounts_controller.py +558,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Pembelian Faktur tidak dapat dilakukan terhadap aset yang ada {1}
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Urgent] Kesalahan saat membuat dokumen berulang % s  untuk% s
+apps/erpnext/erpnext/controllers/accounts_controller.py +602,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Pembelian Faktur tidak dapat dilakukan terhadap aset yang ada {1}
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Penting] Kesalahan saat membuat perulangan %s untuk %s
+DocType: Land Unit,LInked Analysis,Analisis LInked
 DocType: Item Tax,Tax Rate,Tarif Pajak
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} sudah dialokasikan untuk Karyawan {1} untuk periode {2} ke {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +890,Select Item,Pilih Stok Barang
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} sudah dialokasikan bagi Karyawan {1} untuk periode {2} ke {3}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +915,Select Item,Pilih Stok Barang
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +140,Purchase Invoice {0} is already submitted,Faktur Pembelian {0} sudah Terkirim
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Row # {0}: Batch ada harus sama {1} {2}
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Dikonversi ke non-Grup
-apps/erpnext/erpnext/config/stock.py +127,Batch (lot) of an Item.,Batch (banyak) dari Item.
 DocType: C-Form Invoice Detail,Invoice Date,Faktur Tanggal
 DocType: GL Entry,Debit Amount,Jumlah Debit
-apps/erpnext/erpnext/accounts/party.py +253,There can only be 1 Account per Company in {0} {1},Hanya ada 1 Akun per Perusahaan di {0} {1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +407,Please see attachment,Silakan lihat lampiran
+apps/erpnext/erpnext/accounts/party.py +251,There can only be 1 Account per Company in {0} {1},Hanya ada 1 Akun per Perusahaan di {0} {1}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,Silakan lihat lampiran
 DocType: Purchase Order,% Received,% Diterima
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Buat Grup Mahasiswa
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +21,Setup Already Complete!!,Pengaturan Sudah Selesai!!
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Buat Grup Mahasiswa
+DocType: Volunteer,Weekends,Akhir pekan
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Jumlah Catatan Kredit
 DocType: Setup Progress Action,Action Document,Dokumen tindakan
+DocType: Chapter Member,Website URL,URL situs
 ,Finished Goods,Stok Barang Jadi
 DocType: Delivery Note,Instructions,Instruksi
 DocType: Quality Inspection,Inspected By,Diperiksa Oleh
-DocType: Maintenance Visit,Maintenance Type,Tipe Pemeliharaan
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} tidak terdaftar di Kursus {2}
+DocType: Asset Maintenance Log,Maintenance Type,Tipe Pemeliharaan
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} tidak terdaftar di Kursus {2}
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serial ada {0} bukan milik Pengiriman Note {1}
 apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
 apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Tambahkan Item
@@ -487,31 +517,33 @@
 DocType: Packed Item,Packed Item,Stok Barang Kemasan
 apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Pengaturan default untuk transaksi Pembelian.
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Terdapat Biaya Kegiatan untuk Karyawan {0} untuk Jenis Kegiatan - {1}
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Wajib lapangan - Dapatkan Siswa Dari
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Wajib lapangan - Dapatkan Siswa Dari
 DocType: Program Enrollment,Enrolled courses,Kursus yang terdaftar
 DocType: Currency Exchange,Currency Exchange,Kurs Mata Uang
-DocType: Asset,Item Name,Nama Item
+DocType: Opening Invoice Creation Tool Item,Item Name,Nama Item
 DocType: Authorization Rule,Approving User  (above authorized value),Approving User (di atas nilai yang berwenang)
 DocType: Email Digest,Credit Balance,Saldo kredit
 DocType: Employee,Widowed,Janda
 DocType: Request for Quotation,Request for Quotation,Permintaan Quotation
 DocType: Healthcare Settings,Require Lab Test Approval,Memerlukan Lab Test Approval
 DocType: Salary Slip Timesheet,Working Hours,Jam Kerja
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Total Posisi
 DocType: Naming Series,Change the starting / current sequence number of an existing series.,Mengubah mulai / nomor urut saat ini dari seri yang ada.
 DocType: Dosage Strength,Strength,Kekuatan
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1508,Create a new Customer,Buat Pelanggan baru
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1523,Create a new Customer,Buat Pelanggan baru
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Jika beberapa Aturan Harga terus menang, pengguna akan diminta untuk mengatur Prioritas manual untuk menyelesaikan konflik."
 apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Buat Purchase Order
 ,Purchase Register,Register Pembelian
-DocType: Course Scheduling Tool,Rechedule,Rechedule
+DocType: Scheduling Tool,Rechedule,Rechedule
 DocType: Landed Cost Item,Applicable Charges,Biaya yang Berlaku
 DocType: Workstation,Consumable Cost,Biaya Consumable
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',{0} ({1}) harus memiliki akses sebagai 'Pemberi Izin Cuti'
 DocType: Purchase Receipt,Vehicle Date,Tanggal Kendaraan
 DocType: Student Log,Medical,Medis
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Alasan Kehilangan
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +41,Lead Owner cannot be same as the Lead,Pemilik Prospek tidak bisa sama dengan Prospek
-apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not greater than unadjusted amount,jumlah yang dialokasikan tidak bisa lebih besar dari jumlah yang disesuaikan
+apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Perbarui nomor akun
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Pemilik Prospek tidak bisa sama dengan Prospek
+apps/erpnext/erpnext/accounts/utils.py +353,Allocated amount can not greater than unadjusted amount,jumlah yang dialokasikan tidak bisa lebih besar dari jumlah yang disesuaikan
 DocType: Announcement,Receiver,Penerima
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation ditutup pada tanggal berikut sesuai Hari Libur Daftar: {0}
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Peluang
@@ -527,7 +559,7 @@
 DocType: Lab Test Template,No Result,Tidak ada hasil
 DocType: Purchase Invoice Item,Quantity and Rate,Kuantitas dan Harga
 DocType: Delivery Note,% Installed,% Terpasang
-apps/erpnext/erpnext/utilities/user_progress.py +209,Classrooms/ Laboratories etc where lectures can be scheduled.,Ruang kelas / Laboratorium dll di mana kuliah dapat dijadwalkan.
+apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,Ruang kelas / Laboratorium dll di mana kuliah dapat dijadwalkan.
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Silahkan masukkan nama perusahaan terlebih dahulu
 DocType: Purchase Invoice,Supplier Name,Nama Supplier
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Baca Pedoman ERPNEXT
@@ -535,40 +567,45 @@
 DocType: Email Digest,Pending Purchase Orders,Pending Pembelian Pesanan
 DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Nomor Seri Otomatis berdasarkan FIFO
 DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Periksa keunikan nomor Faktur Supplier
+apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Rincian Alamat Utama
 DocType: Vehicle Service,Oil Change,Ganti oli
+DocType: Asset Maintenance Log,Asset Maintenance Log,Log pemeliharaan aset
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.','Sampai Kasus No.' tidak bisa kurang dari 'Dari Kasus No.'
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +142,Non Profit,Non Profit
+DocType: Chapter,Non Profit,Non Profit
 DocType: Production Order,Not Started,Tidak Dimulai
 DocType: Lead,Channel Partner,Chanel Mitra
 DocType: Account,Old Parent,Old Parent
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Bidang Wajib - Tahun Akademik
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Bidang Wajib - Tahun Akademik
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} is not associated with {2} {3},{0} {1} tidak terkait dengan {2} {3}
 DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Sesuaikan teks pengantar yang menjadi bagian dari surel itu. Setiap transaksi memiliki teks pengantar yang terpisah.
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +157,Please set default payable account for the company {0},Harap atur akun hutang default untuk perusahaan {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +182,Please set default payable account for the company {0},Harap atur akun hutang default untuk perusahaan {0}
 DocType: Setup Progress Action,Min Doc Count,Min Doc Count
 apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Pengaturan global untuk semua proses manufaktur.
 DocType: Accounts Settings,Accounts Frozen Upto,Akun dibekukan sampai dengan
 DocType: SMS Log,Sent On,Dikirim Pada
-apps/erpnext/erpnext/stock/doctype/item/item.py +685,Attribute {0} selected multiple times in Attributes Table,Atribut {0} karena beberapa kali dalam Atribut Tabel
+apps/erpnext/erpnext/stock/doctype/item/item.py +671,Attribute {0} selected multiple times in Attributes Table,Atribut {0} karena beberapa kali dalam Atribut Tabel
 DocType: HR Settings,Employee record is created using selected field. ,
 DocType: Sales Order,Not Applicable,Tidak Berlaku
 apps/erpnext/erpnext/config/hr.py +70,Holiday master.,master Hari Libur.
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +77,Opening Invoice Item,Membuka Item Faktur
 DocType: Request for Quotation Item,Required Date,Diperlukan Tanggal
 DocType: Delivery Note,Billing Address,Alamat Penagihan
 DocType: BOM,Costing,Biaya
 DocType: Tax Rule,Billing County,Daerah Penagihan
 DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Jika dicentang, jumlah pajak akan dianggap sebagai sudah termasuk dalam Jumlah Tingkat Cetak / Print"
 DocType: Request for Quotation,Message for Supplier,Pesan Supplier
+DocType: Driver,DRIVER-.#####,SOPIR-.#####
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Jumlah Qty
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,ID Email Guardian2
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,ID Email Guardian2
 DocType: Item,Show in Website (Variant),Tampilkan Website (Variant)
 DocType: Employee,Health Concerns,Kekhawatiran Kesehatan
-DocType: Process Payroll,Select Payroll Period,Pilih Payroll Periode
+DocType: Payroll Entry,Select Payroll Period,Pilih Payroll Periode
 DocType: Purchase Invoice,Unpaid,Tunggakan
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Dicadangkan untuk dijual
 DocType: Packing Slip,From Package No.,Dari Package No
 DocType: Item Attribute,To Range,Berkisar
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Efek Saham dan Deposit
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +44,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Tidak dapat mengubah metode valuasi, karena ada transaksi terhadap beberapa item yang tidak memiliki metode penilaian sendiri"
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Tidak dapat mengubah metode valuasi, karena ada transaksi terhadap beberapa item yang tidak memiliki metode penilaian sendiri"
 apps/erpnext/erpnext/config/healthcare.py +133,Test Sample Master.,Contoh Tes Guru.
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Jumlah cuti wajib dialokasikan
 DocType: Patient,AB Positive,AB Positif
@@ -590,35 +627,39 @@
 DocType: Training Event,Workshop,Bengkel
 DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Peringatkan untuk Pesanan Pembelian
 apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Daftar beberapa pelanggan anda. Bisa organisasi atau individu.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Supplier&gt; Supplier Type
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +21,Enough Parts to Build,Bagian yang cukup untuk Membangun
 DocType: POS Profile User,POS Profile User,Profil Pengguna POS
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Pendapatan Langsung
 DocType: Patient Appointment,Date TIme,Tanggal Waktu
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Account, if grouped by Account","Tidak dapat memfilter berdasarkan Account, jika dikelompokkan berdasarkan Account"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +126,Administrative Officer,Petugas Administrasi
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +22,Please select Course,Silakan pilih Kursus
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,Petugas Administrasi
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Menyiapkan perusahaan dan pajak
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Silakan pilih Kursus
 DocType: Codification Table,Codification Table,Tabel Kodifikasi
 DocType: Timesheet Detail,Hrs,Hrs
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +342,Please select Company,Silakan pilih Perusahaan
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +350,Please select Company,Silakan pilih Perusahaan
 DocType: Stock Entry Detail,Difference Account,Perbedaan Akun
 DocType: Purchase Invoice,Supplier GSTIN,Pemasok GSTIN
 apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,Tidak bisa tugas sedekat tugas yang tergantung {0} tidak tertutup.
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +433,Please enter Warehouse for which Material Request will be raised,Entrikan Gudang yang Material Permintaan akan dibangkitkan
 DocType: Production Order,Additional Operating Cost,Biaya Operasi Tambahan
 DocType: Lab Test Template,Lab Routine,Lab Rutin
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,Kosmetik
-apps/erpnext/erpnext/stock/doctype/item/item.py +545,"To merge, following properties must be same for both items","Untuk bergabung, sifat berikut harus sama untuk kedua item"
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Kosmetik
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Silakan pilih Tanggal Penyelesaian untuk Pemeriksaan Pemeliharaan Aset Selesai
+apps/erpnext/erpnext/stock/doctype/item/item.py +526,"To merge, following properties must be same for both items","Untuk bergabung, sifat berikut harus sama untuk kedua item"
 DocType: Shipping Rule,Net Weight,Berat Bersih
 DocType: Employee,Emergency Phone,Telepon Darurat
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Membeli
 ,Serial No Warranty Expiry,Nomor Serial Garansi telah kadaluarsa
 DocType: Sales Invoice,Offline POS Name,POS Offline Nama
-apps/erpnext/erpnext/utilities/user_progress.py +159,Student Application,Aplikasi siswa
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Harap tentukan nilai untuk Threshold 0%
+apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Aplikasi siswa
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Harap tentukan nilai untuk Threshold 0%
 DocType: Sales Order,To Deliver,Mengirim
 DocType: Purchase Invoice Item,Item,Barang
-apps/erpnext/erpnext/healthcare/setup.py +255,High Sensitivity,Sensitivitas tinggi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2493,Serial no item cannot be a fraction,Serial Item tidak dapat pecahan
+apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Sensitivitas tinggi
+apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Informasi Tipe Sukarela.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2512,Serial no item cannot be a fraction,Serial Item tidak dapat pecahan
 DocType: Journal Entry,Difference (Dr - Cr),Perbedaan (Dr - Cr)
 DocType: Account,Profit and Loss,Laba Rugi
 DocType: Patient,Risk Factors,Faktor risiko
@@ -627,6 +668,7 @@
 apps/erpnext/erpnext/config/stock.py +330,Managing Subcontracting,Pengaturan Subkontrak
 DocType: Vital Signs,Body Temperature,Suhu tubuh
 DocType: Project,Project will be accessible on the website to these users,Proyek akan dapat diakses di website pengguna ini
+DocType: Detected Disease,Disease,Penyakit
 apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Tentukan jenis proyek.
 DocType: Supplier Scorecard,Weighting Function,Fungsi pembobotan
 DocType: Physician,OP Consulting Charge,OP Consulting Charge
@@ -635,27 +677,29 @@
 apps/erpnext/erpnext/setup/doctype/company/company.py +62,Account {0} does not belong to company: {1},Akun {0} bukan milik perusahaan: {1}
 apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Singkatan sudah digunakan untuk perusahaan lain
 DocType: Selling Settings,Default Customer Group,Kelompok Pelanggan Standar
+DocType: Asset Repair,ARLOG-,ARLOG-
 DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Jika disable, lapangan 'Rounded Jumlah' tidak akan terlihat dalam setiap transaksi"
 DocType: BOM,Operating Cost,Biaya Operasi
+DocType: Crop,Produced Items,Item yang Diproduksi
 DocType: Sales Order Item,Gross Profit,Laba Kotor
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Kenaikan tidak bisa 0
 DocType: Production Planning Tool,Material Requirement,Permintaan Material / Bahan
 DocType: Company,Delete Company Transactions,Hapus Transaksi Perusahaan
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +350,Reference No and Reference Date is mandatory for Bank transaction,Referensi ada dan Tanggal referensi wajib untuk transaksi Bank
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,Reference No and Reference Date is mandatory for Bank transaction,Referensi ada dan Tanggal referensi wajib untuk transaksi Bank
 DocType: Purchase Receipt,Add / Edit Taxes and Charges,Tambah / Edit Pajak dan Biaya
 DocType: Payment Entry Reference,Supplier Invoice No,Nomor Faktur Supplier
 DocType: Territory,For reference,Untuk referensi
 DocType: Healthcare Settings,Appointment Confirmation,Konfirmasi perjanjian
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Tidak dapat menghapus No. Seri {0}, karena digunakan dalam transaksi persediaan"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Cr),Penutup (Cr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +253,Closing (Cr),Penutup (Cr)
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Halo
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +110,Move Item,Pindahkan Barang
 DocType: Serial No,Warranty Period (Days),Masa Garansi (Hari)
 DocType: Installation Note Item,Installation Note Item,Laporan Instalasi Stok Barang
 DocType: Production Plan Item,Pending Qty,Qty Tertunda
 DocType: Budget,Ignore,Diabaikan
-apps/erpnext/erpnext/accounts/party.py +372,{0} {1} is not active,{0} {1} tidak aktif
-apps/erpnext/erpnext/config/accounts.py +285,Setup cheque dimensions for printing,dimensi penyiapan cek untuk pencetakan
+apps/erpnext/erpnext/accounts/party.py +384,{0} {1} is not active,{0} {1} tidak aktif
+apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,dimensi penyiapan cek untuk pencetakan
 DocType: Salary Slip,Salary Slip Timesheet,Daftar Absen Slip Gaji
 apps/erpnext/erpnext/controllers/buying_controller.py +157,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Supplier Gudang wajib untuk Pembelian Penerimaan sub-kontrak
 DocType: Pricing Rule,Valid From,Valid Dari
@@ -663,19 +707,21 @@
 DocType: Pricing Rule,Sales Partner,Mitra Penjualan
 apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Semua kartu pemilih Pemasok.
 DocType: Buying Settings,Purchase Receipt Required,Diperlukan Nota Penerimaan
-apps/erpnext/erpnext/stock/doctype/item/item.py +142,Valuation Rate is mandatory if Opening Stock entered,Tingkat Valuasi adalah wajib jika menggunakan Persediaan Pembukaan
+apps/erpnext/erpnext/stock/doctype/item/item.py +144,Valuation Rate is mandatory if Opening Stock entered,Tingkat Valuasi adalah wajib jika menggunakan Persediaan Pembukaan
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +142,No records found in the Invoice table,Tidak ada catatan yang ditemukan dalam tabel Faktur
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,Silakan pilih Perusahaan dan Partai Jenis terlebih dahulu
-apps/erpnext/erpnext/config/accounts.py +301,Financial / accounting year.,Keuangan / akuntansi Tahun Berjalan
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Sudah menetapkan default pada profil pos {0} untuk pengguna {1}, dengan baik dinonaktifkan secara default"
+apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Keuangan / akuntansi Tahun Berjalan
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Nilai akumulasi
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Maaf, Nomor Seri tidak dapat digabungkan"
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +63,Territory is Required in POS Profile,Wilayah Diperlukan di Profil POS
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +68,Territory is Required in POS Profile,Wilayah Diperlukan di Profil POS
 DocType: Supplier,Prevent RFQs,Mencegah RFQs
 apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Membuat Sales Order
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Slip Gaji dikirim untuk periode dari {0} sampai {1}
 DocType: Project Task,Project Task,Tugas Proyek
 ,Lead Id,Id Prospek
 DocType: C-Form Invoice Detail,Grand Total,Nilai Jumlah Total
-DocType: Training Event,Course,kuliah
+DocType: Assessment Plan,Course,kuliah
 DocType: Timesheet,Payslip,payslip
 apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Item Cart
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Tahun Anggaran Tanggal Mulai tidak boleh lebih besar dari Fiscal Year End Tanggal
@@ -688,7 +734,9 @@
 DocType: Job Applicant,Resume Attachment,Lanjutkan Lampiran
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Pelanggan Rutin
 DocType: Leave Control Panel,Allocate,Alokasi
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +804,Sales Return,Retur Penjualan
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Buat Varian
+DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Membuka Invoice Creation Tool
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +851,Sales Return,Retur Penjualan
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Catatan: Jumlah daun dialokasikan {0} tidak boleh kurang dari daun yang telah disetujui {1} untuk periode
 ,Total Stock Summary,Ringkasan Persediaan Total
 DocType: Announcement,Posted By,Dikirim oleh
@@ -699,40 +747,45 @@
 apps/erpnext/erpnext/config/selling.py +28,Customer database.,Database Pelanggan.
 DocType: Quotation,Quotation To,Penawaran Kepada
 DocType: Lead,Middle Income,Penghasilan Menengah
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Cr),Pembukaan (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +849,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,Standar Satuan Ukur untuk Item {0} tidak dapat diubah secara langsung karena Anda telah membuat beberapa transaksi (s) dengan UOM lain. Anda akan perlu untuk membuat item baru menggunakan default UOM berbeda.
-apps/erpnext/erpnext/accounts/utils.py +349,Allocated amount can not be negative,Jumlah yang dialokasikan tidak dijinkan negatif
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +225,Opening (Cr),Pembukaan (Cr)
+apps/erpnext/erpnext/stock/doctype/item/item.py +835,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,Standar Satuan Ukur untuk Item {0} tidak dapat diubah secara langsung karena Anda telah membuat beberapa transaksi (s) dengan UOM lain. Anda akan perlu untuk membuat item baru menggunakan default UOM berbeda.
+apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not be negative,Jumlah yang dialokasikan tidak dijinkan negatif
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Harap atur Perusahaan
 DocType: Purchase Order Item,Billed Amt,Nilai Tagihan
 DocType: Training Result Employee,Training Result Employee,Pelatihan Hasil Karyawan
 DocType: Warehouse,A logical Warehouse against which stock entries are made.,Sebuah Gudang logis dimana entri persediaan dibuat.
 DocType: Repayment Schedule,Principal Amount,Jumlah pokok
 DocType: Employee Loan Application,Total Payable Interest,Total Utang Bunga
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +59,Total Outstanding: {0},Total Posisi: {0}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Total Posisi: {0}
 DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Penjualan Faktur Timesheet
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Referensi ada & Referensi Tanggal diperlukan untuk {0}
-DocType: Process Payroll,Select Payment Account to make Bank Entry,Pilih Account Pembayaran untuk membuat Bank Masuk
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,Reference No & Reference Date is required for {0},Referensi ada & Referensi Tanggal diperlukan untuk {0}
+DocType: Payroll Entry,Select Payment Account to make Bank Entry,Pilih Account Pembayaran untuk membuat Bank Masuk
 apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Buat catatan Karyawan untuk mengelola daun, klaim biaya dan gaji"
 apps/erpnext/erpnext/config/healthcare.py +118,Prescription Period,Periode Resep
 DocType: Restaurant Reservation,Restaurant Reservation,Reservasi Restoran
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +186,Proposal Writing,Penulisan Proposal
+DocType: Land Unit,Land Unit Name,Nama unit tanah
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Penulisan Proposal
 DocType: Payment Entry Deduction,Payment Entry Deduction,Pembayaran Masuk Pengurangan
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Membungkus
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Beritahu Pelanggan via Email
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Sales Person lain {0} ada dengan id Karyawan yang sama
+DocType: Employee Advance,Claimed Amount,Jumlah klaim
 DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Jika dicentang, bahan baku untuk produk yang sub-kontrak akan dimasukkan dalam Permintaan Material"
 apps/erpnext/erpnext/config/healthcare.py +61,Masters,Masters
 DocType: Assessment Plan,Maximum Assessment Score,Skor Penilaian Maksimum
-apps/erpnext/erpnext/config/accounts.py +146,Update Bank Transaction Dates,Tanggal Transaksi pembaruan Bank
+apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Tanggal Transaksi pembaruan Bank
 apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Pelacakan waktu
 DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICATE FOR TRANSPORTER
+apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Baris {0} # Jumlah yang Dibayar tidak boleh lebih besar dari jumlah uang muka yang diminta
 DocType: Fiscal Year Company,Fiscal Year Company,Tahun Fiskal Perusahaan
 DocType: Packing Slip Item,DN Detail,DN Detil
 DocType: Training Event,Conference,Konferensi
 DocType: Timesheet,Billed,Ditagih
 DocType: Batch,Batch Description,Keterangan Batch
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Menciptakan kelompok siswa
-apps/erpnext/erpnext/accounts/utils.py +721,"Payment Gateway Account not created, please create one manually.","Gateway Akun pembayaran tidak dibuat, silakan membuat satu secara manual."
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Menciptakan kelompok siswa
+apps/erpnext/erpnext/accounts/utils.py +724,"Payment Gateway Account not created, please create one manually.","Gateway Akun pembayaran tidak dibuat, silakan membuat satu secara manual."
 DocType: Supplier Scorecard,Per Year,Per tahun
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Tidak memenuhi syarat untuk masuk dalam program ini sesuai DOB
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Tidak memenuhi syarat untuk masuk dalam program ini sesuai DOB
 DocType: Sales Invoice,Sales Taxes and Charges,Pajak Penjualan dan Biaya
 DocType: Employee,Organization Profile,Profil Organisasi
 DocType: Vital Signs,Height (In Meter),Tinggi (In Meter)
@@ -740,26 +793,26 @@
 DocType: Vehicle Service,Vehicle Service,Layanan kendaraan
 apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Secara otomatis memicu permintaan umpan balik berdasarkan kondisi.
 DocType: Employee,Reason for Resignation,Alasan pengunduran diri
-apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Template untuk penilaian kinerja.
+apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Template untuk penilaian kinerja.
 DocType: Sales Invoice,Credit Note Issued,Kredit Catatan Ditempatkan
 DocType: Project Task,Weight,Berat
 DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktur / Jurnal entri Detail
 apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} '{1}' tidak dalam Tahun Anggaran {2}
 DocType: Buying Settings,Settings for Buying Module,Pengaturan untuk Modul Pembelian
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Aset {0} bukan milik perusahaan {1}
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Aset {0} bukan milik perusahaan {1}
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Cukup masukkan Nota Penerimaan terlebih dahulu
 DocType: Buying Settings,Supplier Naming By,Penamaan Supplier Berdasarkan
 DocType: Activity Type,Default Costing Rate,Standar Tingkat Biaya
 DocType: Maintenance Schedule,Maintenance Schedule,Jadwal Pemeliharaan
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Kemudian Aturan Harga disaring berdasarkan Pelanggan, Kelompok Pelanggan, Wilayah, Pemasok, Jenis Pemasok, Kampanye, Mitra Penjualan, dll."
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Perubahan Nilai bersih dalam Persediaan
-apps/erpnext/erpnext/config/hr.py +157,Employee Loan Management,Manajemen Kredit Karyawan
+apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Manajemen Kredit Karyawan
 DocType: Employee,Passport Number,Nomor Paspor
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Hubungan dengan Guardian2
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +120,Manager,Manajer
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Hubungan dengan Guardian2
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Manajer
 DocType: Payment Entry,Payment From / To,Pembayaran Dari / Untuk
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +127,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},batas kredit baru kurang dari jumlah yang luar biasa saat ini bagi pelanggan. batas kredit harus minimal {0}
-apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,'Berdasarkan' dan 'Kelompokkan Dengan' tidak bisa sama
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +155,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},batas kredit baru kurang dari jumlah yang luar biasa saat ini bagi pelanggan. batas kredit harus minimal {0}
+apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,'Berdasarkan' dan 'Kelompokkan Menurut' tidak boleh sama
 DocType: Sales Person,Sales Person Targets,Target Sales Person
 DocType: Installation Note,IN-,DI-
 DocType: Production Order Operation,In minutes,Dalam menit
@@ -767,43 +820,46 @@
 DocType: Lab Test Template,Compound,Senyawa
 DocType: Student Batch Name,Batch Name,Nama Batch
 DocType: Fee Validity,Max number of visit,Jumlah kunjungan maksimal
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +319,Timesheet created:,Absen dibuat:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +908,Please set default Cash or Bank account in Mode of Payment {0},Silakan set Cash standar atau rekening Bank Mode Pembayaran {0}
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +24,Enroll,Mendaftar
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Absen dibuat:
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +920,Please set default Cash or Bank account in Mode of Payment {0},Silakan set Cash standar atau rekening Bank Mode Pembayaran {0}
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,Mendaftar
 DocType: GST Settings,GST Settings,Pengaturan GST
 DocType: Selling Settings,Customer Naming By,Penamaan Pelanggan Dengan
 DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Akan menampilkan siswa sebagai Hadir di Student Bulanan Kehadiran Laporan
 DocType: Depreciation Schedule,Depreciation Amount,penyusutan Jumlah
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Konversikan ke Grup
+DocType: Delivery Trip,TOUR-.#####,WISATA-.#####
 DocType: Activity Cost,Activity Type,Jenis Kegiatan
 DocType: Request for Quotation,For individual supplier,Untuk pemasok individual
 DocType: BOM Operation,Base Hour Rate(Company Currency),Dasar Harga Perjam (Mata Uang Perusahaan)
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Jumlah Telah Terikirim
-DocType: Supplier,Fixed Days,Hari Tetap
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests,Tes Laboratorium
+DocType: Company,Fixed Days,Hari Tetap
 DocType: Quotation Item,Item Balance,Item Balance
 DocType: Sales Invoice,Packing List,Packing List
 apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Order Pembelian yang diberikan kepada Supplier.
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,Penerbitan
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Penerbitan
 DocType: Activity Cost,Projects User,Pengguna Proyek
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Dikonsumsi
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} tidak ditemukan dalam tabel Rincian Tagihan
+DocType: Asset,Asset Owner Company,Perusahaan Pemilik Aset
 DocType: Company,Round Off Cost Center,Pembulatan Pusat Biaya
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +227,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Pemeliharaan Kunjungan {0} harus dibatalkan sebelum membatalkan Sales Order ini
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Pemeliharaan Kunjungan {0} harus dibatalkan sebelum membatalkan Sales Order ini
+DocType: Asset Maintenance Log,AML-,AML-
 DocType: Item,Material Transfer,Transfer Barang
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Tidak dapat menemukan jalan untuk
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +211,Opening (Dr),Pembukaan (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Dr),Pembukaan (Dr)
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Posting timestamp harus setelah {0}
 apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Membuat dokumen berulang
 ,GST Itemised Purchase Register,Daftar Pembelian Item GST
+DocType: Course Scheduling Tool,Reschedule,Penjadwalan ulang
 DocType: Employee Loan,Total Interest Payable,Total Utang Bunga
 DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Biaya Pajak dan Landing Cost
 DocType: Production Order Operation,Actual Start Time,Waktu Mulai Aktual
 DocType: BOM Operation,Operation Time,Waktu Operasi
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +293,Finish,Selesai
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +395,Base,Dasar
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +315,Finish,Selesai
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Dasar
 DocType: Timesheet,Total Billed Hours,Total Jam Ditagih
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1351,Write Off Amount,Jumlah Nilai Write Off
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1438,Write Off Amount,Jumlah Nilai Write Off
 DocType: Leave Block List Allow,Allow User,Izinkan Pengguna
 DocType: Journal Entry,Bill No,Nomor Tagihan
 DocType: Company,Gain/Loss Account on Asset Disposal,Gain / Loss Account pada Asset Disposal
@@ -817,33 +873,38 @@
 DocType: Student Attendance,Student Attendance,Kehadiran mahasiswa
 DocType: Sales Invoice Timesheet,Time Sheet,Lembar waktu
 DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush Bahan Baku Berbasis Pada
-DocType: Interest,Interest,Bunga
+DocType: Lead,Lead is an Organization,Lead adalah sebuah Organisasi
+DocType: Guardian Interest,Interest,Bunga
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Pra penjualan
 DocType: Purchase Receipt,Other Details,Detail lainnya
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
 DocType: Lab Test,Test Template,Uji Template
 DocType: Restaurant Order Entry Item,Served,Melayani
+apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Informasi pasal
 DocType: Account,Accounts,Akun / Rekening
 DocType: Vehicle,Odometer Value (Last),Odometer Nilai (terakhir)
 apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Template dari kriteria scorecard pemasok.
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +105,Marketing,Marketing
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Marketing
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,Entri pembayaran sudah dibuat
 DocType: Request for Quotation,Get Suppliers,Dapatkan Pemasok
 DocType: Purchase Receipt Item Supplied,Current Stock,Persediaan saat ini
-apps/erpnext/erpnext/controllers/accounts_controller.py +545,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Aset {1} tidak terkait dengan Butir {2}
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +377,Preview Salary Slip,Slip Gaji Preview
+apps/erpnext/erpnext/controllers/accounts_controller.py +589,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Aset {1} tidak terkait dengan Butir {2}
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Slip Gaji Preview
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Akun {0} telah dimasukkan beberapa kali
 DocType: Account,Expenses Included In Valuation,Biaya Termasuk di Dalam Penilaian Barang
+apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +23,You can only renew if your membership expires within 30 days,Anda hanya bisa memperpanjang jika keanggotaan Anda akan berakhir dalam 30 hari
+DocType: Land Unit,Longitude,Garis bujur
 ,Absent Student Report,Laporan Absen Siswa
+DocType: Crop,Crop Spacing UOM,Tanaman Jarak UOM
 DocType: Email Digest,Next email will be sent on:,Email berikutnya akan dikirim pada:
 DocType: Offer Letter Term,Offer Letter Term,Term Surat Penawaran
 DocType: Supplier Scorecard,Per Week,Per minggu
-apps/erpnext/erpnext/stock/doctype/item/item.py +658,Item has variants.,Item memiliki varian.
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Jumlah Siswa
+apps/erpnext/erpnext/stock/doctype/item/item.py +639,Item has variants.,Item memiliki varian.
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Jumlah Siswa
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Item {0} tidak ditemukan
 DocType: Bin,Stock Value,Nilai Persediaan
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +41,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,"Catatan biaya akan dibuat di latar belakang. Jika ada kesalahan, pesan kesalahan akan diperbarui dalam Schedule."
-apps/erpnext/erpnext/accounts/doctype/account/account.py +26,Company {0} does not exist,Perusahaan {0} tidak ada
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,"Catatan biaya akan dibuat di latar belakang. Jika ada kesalahan, pesan kesalahan akan diperbarui dalam Schedule."
+apps/erpnext/erpnext/accounts/doctype/account/account.py +241,Company {0} does not exist,Perusahaan {0} tidak ada
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} memiliki validitas biaya sampai {1}
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Jenis Tingkat Tree
 DocType: BOM Explosion Item,Qty Consumed Per Unit,Kuantitas Dikonsumsi Per Unit
@@ -851,42 +912,46 @@
 DocType: Material Request Item,Quantity and Warehouse,Kuantitas dan Gudang
 DocType: Hub Settings,Unregister,Unregister
 DocType: Sales Invoice,Commission Rate (%),Komisi Rate (%)
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +24,Please select Program,Silahkan pilih Program
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Silahkan pilih Program
 DocType: Project,Estimated Cost,Estimasi biaya
 DocType: Purchase Order,Link to material requests,Link ke permintaan bahan
 DocType: Hub Settings,Publish,Menerbitkan
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Dirgantara
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Dirgantara
 DocType: Journal Entry,Credit Card Entry,Entri Kartu Kredit
 apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Perusahaan dan Account
 apps/erpnext/erpnext/config/healthcare.py +108,Appointment Type Master,Jenis Pengangkatan Guru
-apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Stok Barang yang diterima dari Supplier.
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +58,In Value,Nilai
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,Nilai
 DocType: Lead,Campaign Name,Nama Promosi Kampanye
 DocType: Selling Settings,Close Opportunity After Days,Tutup Peluang Setelah Days
 ,Reserved,Ditahan
+DocType: Driver,License Details,Rincian lisensi
 DocType: Purchase Order,Supply Raw Materials,Pasokan Bahan Baku
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Aset Lancar
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +94,{0} is not a stock Item,{0} bukan Barang persediaan
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,{0} is not a stock Item,{0} bukan Barang persediaan
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Silakan bagikan umpan balik Anda ke pelatihan dengan mengklik &#39;Feedback Training&#39; dan kemudian &#39;New&#39;
 DocType: Mode of Payment Account,Default Account,Akun Standar
+apps/erpnext/erpnext/stock/doctype/item/item.py +262,Please select Sample Retention Warehouse in Stock Settings first,Silahkan pilih Sampel Retention Warehouse di Stock Settings terlebih dahulu
 DocType: Payment Entry,Received Amount (Company Currency),Menerima Jumlah (Perusahaan Mata Uang)
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,Prospek harus diatur apabila Peluang berasal dari Prospek
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Silakan pilih dari hari mingguan
 DocType: Patient,O Negative,O negatif
 DocType: Production Order Operation,Planned End Time,Rencana Waktu Berakhir
 ,Sales Person Target Variance Item Group-Wise,Sales Person Sasaran Variance Stok Barang Group-Wise
-apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Account with existing transaction cannot be converted to ledger,Akun dengan transaksi yang ada tidak dapat dikonversi ke buku besar
+apps/erpnext/erpnext/accounts/doctype/account/account.py +95,Account with existing transaction cannot be converted to ledger,Akun dengan transaksi yang ada tidak dapat dikonversi ke buku besar
+apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Rincian Jenis Memebership
 DocType: Delivery Note,Customer's Purchase Order No,Nomor Order Pembelian Pelanggan
 DocType: Budget,Budget Against,anggaran Terhadap
 DocType: Employee,Cell Number,Nomor HP
-apps/erpnext/erpnext/stock/reorder_item.py +177,Auto Material Requests Generated,Pembuatan Form Permintaan Material Otomatis
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Tidak ada karyawan untuk kriteria yang diberikan. Periksa bahwa Slip Gaji belum pernah dibuat.
+apps/erpnext/erpnext/stock/reorder_item.py +190,Auto Material Requests Generated,Pembuatan Form Permintaan Material Otomatis
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Kalah
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,Anda tidak dapat memasukkan voucher saat ini di kolom 'Terhadap Entri Jurnal'
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,You can not enter current voucher in 'Against Journal Entry' column,Anda tidak dapat memasukkan voucher saat ini di kolom 'Terhadap Entri Jurnal'
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Dicadangkan untuk manufaktur
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,Energi
+DocType: Soil Texture,Sand,Pasir
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Energi
 DocType: Opportunity,Opportunity From,Peluang Dari
 apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Laporan gaji bulanan.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +876,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Baris {0}: {1} Nomor seri diperlukan untuk Item {2}. Anda telah memberikan {3}.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +881,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Baris {0}: {1} Nomor seri diperlukan untuk Item {2}. Anda telah memberikan {3}.
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Silahkan pilih sebuah tabel
 DocType: BOM,Website Specifications,Website Spesifikasi
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} adalah alamat email yang tidak valid di &#39;Penerima&#39;
@@ -894,12 +959,14 @@
 apps/erpnext/erpnext/config/healthcare.py +143,Antibiotic.,Antibiotika.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Dari {0} tipe {1}
 DocType: Warranty Claim,CI-,cipher
-apps/erpnext/erpnext/controllers/buying_controller.py +291,Row {0}: Conversion Factor is mandatory,Row {0}: Faktor Konversi adalah wajib
-DocType: Employee,A+,A +
+apps/erpnext/erpnext/controllers/buying_controller.py +292,Row {0}: Conversion Factor is mandatory,Row {0}: Faktor Konversi adalah wajib
+DocType: Student,A+,A +
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +326,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Beberapa Aturan Harga ada dengan kriteria yang sama, silahkan menyelesaikan konflik dengan menetapkan prioritas. Harga Aturan: {0}"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +501,Cannot deactivate or cancel BOM as it is linked with other BOMs,Tidak bisa menonaktifkan atau membatalkan BOM seperti yang terkait dengan BOMs lainnya
-DocType: Opportunity,Maintenance,Pemeliharaan
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +504,Cannot deactivate or cancel BOM as it is linked with other BOMs,Tidak bisa menonaktifkan atau membatalkan BOM seperti yang terkait dengan BOMs lainnya
+DocType: Asset,Maintenance,Pemeliharaan
 DocType: Item Attribute Value,Item Attribute Value,Nilai Item Atribut
+DocType: Item,Maximum sample quantity that can be retained,Jumlah sampel maksimal yang bisa dipertahankan
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +393,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Baris {0} # Item {1} tidak dapat ditransfer lebih dari {2} terhadap Pesanan Pembelian {3}
 apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Kampanye penjualan.
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,membuat Timesheet
 DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
@@ -930,21 +997,25 @@
 DocType: Expense Claim Detail,Expense Claim Type,Tipe Beban Klaim
 DocType: Shopping Cart Settings,Default settings for Shopping Cart,Pengaturan default untuk Belanja
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Tambahkan Timeslots
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Aset membatalkan via Journal Entri {0}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Aset membatalkan via Journal Entri {0}
 DocType: Employee Loan,Interest Income Account,Akun Pendapatan Bunga
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Bioteknologi
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Tinjau Undangan Dikirim
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Bioteknologi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Beban Pemeliharaan Kantor
 apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Pergi ke
 apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Mengatur Akun Email
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,Entrikan Stok Barang terlebih dahulu
+DocType: Asset Repair,Downtime,Downtime
 DocType: Account,Liability,Kewajiban
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sanksi Jumlah tidak dapat lebih besar dari Klaim Jumlah dalam Row {0}.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +234,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sanksi Jumlah tidak dapat lebih besar dari Klaim Jumlah dalam Row {0}.
 DocType: Salary Detail,Do not include in total,Jangan termasuk secara total
 DocType: Company,Default Cost of Goods Sold Account,Standar Harga Pokok Penjualan
-apps/erpnext/erpnext/stock/get_item_details.py +319,Price List not selected,Daftar Harga tidak dipilih
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +964,Sample quantity {0} cannot be more than received quantity {1},Kuantitas sampel {0} tidak boleh lebih dari jumlah yang diterima {1}
+apps/erpnext/erpnext/stock/get_item_details.py +362,Price List not selected,Daftar Harga tidak dipilih
 DocType: Employee,Family Background,Latar Belakang Keluarga
 DocType: Request for Quotation Supplier,Send Email,Kirim Email
-apps/erpnext/erpnext/stock/doctype/item/item.py +216,Warning: Invalid Attachment {0},Peringatan: Lampiran tidak valid {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +218,Warning: Invalid Attachment {0},Peringatan: Lampiran tidak valid {0}
+DocType: Item,Max Sample Quantity,Jumlah Kuantitas Maks
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +764,No Permission,Tidak ada Izin
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +438,Quote Requested,Permintaan Kutipan
 DocType: Vital Signs,Heart Rate / Pulse,Heart Rate / Pulse
@@ -952,32 +1023,34 @@
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +50,"To filter based on Party, select Party Type first","Untuk menyaring berdasarkan Party, pilih Partai Ketik terlebih dahulu"
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},'Pembaruan Persediaan’ tidak dapat dipilih karena barang tidak dikirim melalui {0}
 DocType: Vehicle,Acquisition Date,Tanggal akuisisi
-apps/erpnext/erpnext/utilities/user_progress.py +125,Nos,Nos
+apps/erpnext/erpnext/utilities/user_progress.py +143,Nos,Nos
 DocType: Item,Items with higher weightage will be shown higher,Item dengan weightage lebih tinggi akan ditampilkan lebih tinggi
+apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Tes Laboratorium dan Tanda Vital
 DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Rincian Rekonsiliasi Bank
-apps/erpnext/erpnext/controllers/accounts_controller.py +549,Row #{0}: Asset {1} must be submitted,Row # {0}: Aset {1} harus diserahkan
+apps/erpnext/erpnext/controllers/accounts_controller.py +593,Row #{0}: Asset {1} must be submitted,Row # {0}: Aset {1} harus diserahkan
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Tidak ada karyawan yang ditemukan
 DocType: Subscription,Stopped,Terhenti
 DocType: Item,If subcontracted to a vendor,Jika subkontrak ke pemasok
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +111,Student Group is already updated.,Student Group sudah diupdate
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Student Group sudah diupdate
 DocType: SMS Center,All Customer Contact,Semua Kontak Pelanggan
-apps/erpnext/erpnext/config/stock.py +158,Upload stock balance via csv.,Unggah saldo persediaan melalui csv.
-DocType: Warehouse,Tree Details,Detail pohon
+DocType: Land Unit,Tree Details,Detail pohon
 DocType: Training Event,Event Status,Status acara
+DocType: Volunteer,Availability Timeslot,Ketersediaan Timeslot
 ,Support Analytics,Dukungan Analytics
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Jika Anda memiliki pertanyaan, silakan kembali ke kami."
 DocType: Item,Website Warehouse,Situs Gudang
 DocType: Payment Reconciliation,Minimum Invoice Amount,Nilai Minimum Faktur
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Pusat Biaya {2} bukan milik Perusahaan {3}
+apps/erpnext/erpnext/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Upload kepala surat Anda (Jaga agar web semudah 900px dengan 100px)
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Akun {2} tidak boleh Kelompok
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Item Row {idx}: {doctype} {DOCNAME} tidak ada di atas &#39;{doctype}&#39; table
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +289,Timesheet {0} is already completed or cancelled,Absen {0} sudah selesai atau dibatalkan
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +291,Timesheet {0} is already completed or cancelled,Absen {0} sudah selesai atau dibatalkan
 apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Tidak ada tugas
 DocType: Item Variant Settings,Copy Fields to Variant,Copy Fields ke Variant
 DocType: Asset,Opening Accumulated Depreciation,Membuka Penyusutan Akumulasi
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Skor harus kurang dari atau sama dengan 5
 DocType: Program Enrollment Tool,Program Enrollment Tool,Program Pendaftaran Alat
-apps/erpnext/erpnext/config/accounts.py +343,C-Form records,C-Form catatan
+apps/erpnext/erpnext/config/accounts.py +335,C-Form records,C-Form catatan
 apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Pelanggan dan Pemasok
 DocType: Email Digest,Email Digest Settings,Pengaturan Surel Ringkasan
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +354,Thank you for your business!,Terima kasih untuk bisnis Anda!
@@ -988,43 +1061,48 @@
 DocType: HR Settings,Retirement Age,Umur pensiun
 DocType: Bin,Moving Average Rate,Tingkat Moving Average
 DocType: Production Planning Tool,Select Items,Pilih Produk
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} terhadap Bill {1} tanggal {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +370,{0} against Bill {1} dated {2},{0} terhadap Tagihan {1} tanggal {2}
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Lembaga Penyiapan
 DocType: Program Enrollment,Vehicle/Bus Number,Kendaraan / Nomor Bus
-apps/erpnext/erpnext/schools/doctype/course/course.js +17,Course Schedule,Jadwal Kuliah
+apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Jadwal Kuliah
 DocType: Request for Quotation Supplier,Quote Status,Status Penawaran
 DocType: Maintenance Visit,Completion Status,Status Penyelesaian
 DocType: HR Settings,Enter retirement age in years,Memasuki usia pensiun di tahun
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +252,Target Warehouse,Target Gudang
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +118,Please select a warehouse,Silahkan pilih gudang
+DocType: Crop,Target Warehouse,Target Gudang
+DocType: Payroll Employee Detail,Payroll Employee Detail,Daftar gaji karyawan
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,Silahkan pilih gudang
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Silakan setup seri penomoran untuk Kehadiran melalui Setup&gt; Numbering Series
 DocType: Cheque Print Template,Starting location from left edge,Mulai lokasi dari tepi kiri
 DocType: Item,Allow over delivery or receipt upto this percent,Biarkan selama pengiriman atau penerimaan upto persen ini
 DocType: Stock Entry,STE-,Ste-
 DocType: Upload Attendance,Import Attendance,Impor Absensi
 apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Semua Grup Stok Barang/Item
-DocType: Process Payroll,Activity Log,Log Aktivitas
 apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Laba / Rugi
 apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Secara otomatis menulis pesan pada pengajuan transaksi.
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Harap tentukan Seri Penamaan untuk {0} melalui Setup&gt; Settings&gt; Naming Series
 DocType: Production Order,Item To Manufacture,Stok Barang Untuk Produksi
-apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} Status adalah {2}
+apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} status adalah {2}
+DocType: Water Analysis,Collection Temperature ,Suhu Koleksi
 DocType: Employee,Provide Email Address registered in company,Sediakan Alamat Email yang terdaftar di perusahaan
 DocType: Shopping Cart Settings,Enable Checkout,aktifkan Checkout
 apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Order Pembelian untuk Dibayar
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Proyeksi Qty
 DocType: Sales Invoice,Payment Due Date,Tanggal Jatuh Tempo Pembayaran
 DocType: Drug Prescription,Interval UOM,Interval UOM
-apps/erpnext/erpnext/stock/doctype/item/item.js +363,Item Variant {0} already exists with same attributes,Item Varian {0} sudah ada dengan atribut yang sama
+apps/erpnext/erpnext/stock/doctype/item/item.js +489,Item Variant {0} already exists with same attributes,Item Varian {0} sudah ada dengan atribut yang sama
 DocType: Item,Hub Publishing Details,Rincian Hub Publishing
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening','Awal'
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Terbuka yang Harus Dilakukan
 DocType: Notification Control,Delivery Note Message,Pesan Nota Pengiriman
 DocType: Lab Test Template,Result Format,Format Hasil
 DocType: Expense Claim,Expenses,Biaya / Beban
+DocType: Delivery Stop,Delivery Notes,Catatan pengiriman
 DocType: Item Variant Attribute,Item Variant Attribute,Item Varian Atribut
 ,Purchase Receipt Trends,Tren Nota Penerimaan
-DocType: Process Payroll,Bimonthly,Dua bulan sekali
+DocType: Payroll Entry,Bimonthly,Dua bulan sekali
 DocType: Vehicle Service,Brake Pad,Bantalan Rem
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +115,Research & Development,Penelitian & Pengembangan
+DocType: Fertilizer,Fertilizer Contents,Isi pupuk
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Penelitian & Pengembangan
 apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Nilai Tertagih
 DocType: Company,Registration Details,Detail Pendaftaran
 DocType: Timesheet,Total Billed Amount,Jumlah Total Ditagih
@@ -1036,16 +1114,18 @@
 DocType: Sales Team,Incentives,Insentif
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +64,Register for Hub,Mendaftar untuk Hub
 DocType: SMS Log,Requested Numbers,Nomor yang Diminta
+DocType: Volunteer,Evening,Malam
 DocType: Production Planning Tool,Only Obtain Raw Materials,Hanya Mendapatkan Bahan Baku
-apps/erpnext/erpnext/config/hr.py +142,Performance appraisal.,Penilaian kinerja.
+DocType: Customer,Bypass credit limit check at Sales Order,Bataskan cek batas kredit pada Sales Order
+apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Penilaian kinerja.
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Mengaktifkan &#39;Gunakan untuk Keranjang Belanja&#39;, sebagai Keranjang Belanja diaktifkan dan harus ada setidaknya satu Rule Pajak untuk Belanja"
-apps/erpnext/erpnext/controllers/accounts_controller.py +347,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Masuk pembayaran {0} terkait terhadap Orde {1}, memeriksa apakah itu harus ditarik sebagai uang muka dalam faktur ini."
+apps/erpnext/erpnext/controllers/accounts_controller.py +391,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Masuk pembayaran {0} terkait terhadap Orde {1}, memeriksa apakah itu harus ditarik sebagai uang muka dalam faktur ini."
 DocType: Sales Invoice Item,Stock Details,Rincian Persediaan
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Nilai Proyek
 apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,POS
 DocType: Fee Schedule,Fee Creation Status,Status Penciptaan Biaya
 DocType: Vehicle Log,Odometer Reading,Pembacaan odometer
-apps/erpnext/erpnext/accounts/doctype/account/account.py +119,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Saldo rekening telah berada di Kredit, Anda tidak diizinkan untuk mengatur 'Balance Harus' sebagai 'Debit'"
+apps/erpnext/erpnext/accounts/doctype/account/account.py +118,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Saldo rekening telah berada di Kredit, Anda tidak diizinkan untuk mengatur 'Balance Harus' sebagai 'Debit'"
 DocType: Account,Balance must be,Saldo harus
 DocType: Hub Settings,Publish Pricing,Publikasikan Harga
 DocType: Notification Control,Expense Claim Rejected Message,Beban Klaim Ditolak Pesan
@@ -1054,12 +1134,15 @@
 DocType: Purchase Invoice Item,Rejected Qty,ditolak Qty
 DocType: Setup Progress Action,Action Field,Bidang Aksi
 DocType: Healthcare Settings,Manage Customer,Kelola Pelanggan
+DocType: Delivery Trip,Delivery Stops,Pengiriman Berhenti
 DocType: Salary Slip,Working Days,Hari Kerja
 DocType: Serial No,Incoming Rate,Harga Penerimaan
 DocType: Packing Slip,Gross Weight,Berat Kotor
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Aktifkan Hub
-apps/erpnext/erpnext/public/js/setup_wizard.js +107,The name of your company for which you are setting up this system.,Nama perusahaan Anda yang Anda sedang mengatur sistem ini.
+apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,Nama perusahaan Anda yang Anda sedang mengatur sistem ini.
 DocType: HR Settings,Include holidays in Total no. of Working Days,Sertakan Hari Libur di total no. dari Hari Kerja
+apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Siapkan Institut Anda di ERPNext
+DocType: Agriculture Analysis Criteria,Plant Analysis,Analisis Tanaman
 DocType: Job Applicant,Hold,Ditahan
 DocType: Employee,Date of Joining,Tanggal Bergabung
 DocType: Naming Series,Update Series,Pembaruan Series
@@ -1067,27 +1150,31 @@
 DocType: Restaurant Table,Minimum Seating,Tempat Duduk Minimal
 DocType: Item Attribute,Item Attribute Values,Item Nilai Atribut
 DocType: Examination Result,Examination Result,Hasil pemeriksaan
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +817,Purchase Receipt,Nota Penerimaan
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +843,Purchase Receipt,Nota Penerimaan
 ,Received Items To Be Billed,Produk Diterima Akan Ditagih
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +173,Submitted Salary Slips,Dikirim Slips Gaji
-apps/erpnext/erpnext/config/accounts.py +311,Currency exchange rate master.,Master Nilai Mata Uang
+apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Master Nilai Mata Uang
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +198,Reference Doctype must be one of {0},Referensi DOCTYPE harus menjadi salah satu {0}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +302,Unable to find Time Slot in the next {0} days for Operation {1},Tidak dapat menemukan waktu Slot di {0} hari berikutnya untuk Operasi {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},Tidak dapat menemukan waktu Slot di {0} hari berikutnya untuk Operasi {1}
 DocType: Production Order,Plan material for sub-assemblies,Planning Material untuk Barang Rakitan
 apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Mitra Penjualan dan Wilayah
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +581,BOM {0} must be active,BOM {0} harus aktif
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +585,BOM {0} must be active,BOM {0} harus aktif
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +221,Closing (Opening + Total),Penutupan (Pembukaan + Total)
 DocType: Journal Entry,Depreciation Entry,penyusutan Masuk
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Silakan pilih jenis dokumen terlebih dahulu
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Batal Kunjungan Material {0} sebelum membatalkan ini Maintenance Visit
+DocType: Crop Cycle,ISO 8016 standard,Standar ISO 8016
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Serial ada {0} bukan milik Stok Barang {1}
 DocType: Purchase Receipt Item Supplied,Required Qty,Qty Diperlukan
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Gudang dengan transaksi yang ada tidak dapat dikonversi ke buku besar.
 DocType: Bank Reconciliation,Total Amount,Nilai Total
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +32,Internet Publishing,Penerbitan Internet
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Penerbitan Internet
 DocType: Prescription Duration,Number,Jumlah
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Membuat {0} Faktur
 DocType: Medical Code,Medical Code Standard,Standar Kode Medis
+DocType: Soil Texture,Clay Composition (%),Komposisi Tanah Liar (%)
 DocType: Production Planning Tool,Production Orders,Order Produksi
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +62,Balance Value,Nilai Saldo
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Harap simpan sebelum menugaskan tugas.
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Balance Value,Nilai Saldo
 DocType: Lab Test,Lab Technician,Teknisi laboratorium
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Daftar Harga Jual
 DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
@@ -1099,31 +1186,33 @@
 DocType: Supplier,Default Payable Accounts,Standar Akun Hutang
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Karyawan {0} tidak aktif atau tidak ada
 DocType: Fee Structure,Components,komponen
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +251,Please enter Asset Category in Item {0},Cukup masukkan Aset Kategori dalam angka {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +653,Item Variants {0} updated,Item Varian {0} diperbarui
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +272,Please enter Asset Category in Item {0},Cukup masukkan Aset Kategori dalam angka {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +634,Item Variants {0} updated,Item Varian {0} diperbarui
 DocType: Quality Inspection Reading,Reading 6,Membaca 6
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
 of this","untuk dihasilkan. Jika tertunda, Anda harus mengubah secara manual bidang &quot;Ulangi pada Hari Bulan&quot; ini"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +919,Cannot {0} {1} {2} without any negative outstanding invoice,Tidak bisa {0} {1} {2} tanpa faktur yang beredar negatif
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,Tidak bisa {0} {1} {2} tanpa faktur yang beredar negatif
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Uang Muka Faktur Pembelian
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Baris {0}: entry Kredit tidak dapat dihubungkan dengan {1}
-apps/erpnext/erpnext/config/accounts.py +254,Define budget for a financial year.,Tentukan anggaran untuk tahun keuangan.
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +197,Row {0}: Credit entry can not be linked with a {1},Baris {0}: entry Kredit tidak dapat dihubungkan dengan {1}
+apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Tentukan anggaran untuk tahun keuangan.
 DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Standar rekening Bank / Cash akan secara otomatis diperbarui di POS Invoice saat mode ini dipilih.
 DocType: Lead,LEAD-,PROSPEK-
 DocType: Employee,Permanent Address Is,Alamat Permanen Adalah:
 DocType: Production Order Operation,Operation completed for how many finished goods?,Operasi selesai untuk berapa banyak Stok Barang jadi?
-apps/erpnext/erpnext/public/js/setup_wizard.js +47,The Brand,Merek
+DocType: Payment Terms Template,Payment Terms Template,Template Persyaratan Pembayaran
+apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Merek
 DocType: Employee,Exit Interview Details,Detail Exit Interview
 DocType: Item,Is Purchase Item,Stok Dibeli dari Supplier
-DocType: Asset,Purchase Invoice,Faktur Pembelian
+DocType: Journal Entry Account,Purchase Invoice,Faktur Pembelian
 DocType: Stock Ledger Entry,Voucher Detail No,Nomor Detail Voucher
-apps/erpnext/erpnext/accounts/page/pos/pos.js +765,New Sales Invoice,Baru Faktur Penjualan
+apps/erpnext/erpnext/accounts/page/pos/pos.js +780,New Sales Invoice,Baru Faktur Penjualan
 DocType: Stock Entry,Total Outgoing Value,Nilai Total Keluaran
 DocType: Physician,Appointments,Janji
 apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Tanggal dan Closing Date membuka harus berada dalam Tahun Anggaran yang sama
 DocType: Lead,Request for Information,Request for Information
 ,LeaderBoard,LeaderBoard
-apps/erpnext/erpnext/accounts/page/pos/pos.js +778,Sync Offline Invoices,Sinkronisasi Offline Faktur
+DocType: Sales Invoice Item,Rate With Margin (Company Currency),Tingkat Dengan Margin (Mata Uang Perusahaan)
+apps/erpnext/erpnext/accounts/page/pos/pos.js +793,Sync Offline Invoices,Sinkronisasi Offline Faktur
 DocType: Payment Request,Paid,Dibayar
 DocType: Program Fee,Program Fee,Biaya Program
 DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
@@ -1133,13 +1222,14 @@
 DocType: Guardian,Guardian Name,Nama wali
 DocType: Cheque Print Template,Has Print Format,Memiliki Print Format
 DocType: Employee Loan,Sanctioned,sanksi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +73, is mandatory. Maybe Currency Exchange record is not created for ,Wajib diisi. Mungkin Kurs Mata Uang belum dibuat untuk
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +112,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Silakan tentukan Serial ada untuk Item {1}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +622,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Untuk barang-barang 'Bundel Produk', Gudang, Nomor Serial dan Nomor Batch akan diperhitungkan dari tabel 'Packing List'. Bila Gudang dan Nomor Batch sama untuk semua barang-barang kemasan dari segala barang 'Bundel Produk', maka nilai tersebut dapat dimasukkan dalam tabel Barang utama, nilai tersebut akan disalin ke tabel 'Packing List'."
-DocType: Job Opening,Publish on website,Mempublikasikan di website
-apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Pengiriman ke pelanggan.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +641,Supplier Invoice Date cannot be greater than Posting Date,Pemasok Faktur Tanggal tidak dapat lebih besar dari Posting Tanggal
+apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,wajib diisi. Mungkin Kurs Mata Uang belum dibuat untuk
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Silakan tentukan Serial ada untuk Item {1}
+DocType: Crop Cycle,Crop Cycle,Siklus Tanaman
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +632,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Untuk barang-barang 'Bundel Produk', Gudang, Nomor Serial dan Nomor Batch akan diperhitungkan dari tabel 'Packing List'. Bila Gudang dan Nomor Batch sama untuk semua barang-barang kemasan dari segala barang 'Bundel Produk', maka nilai tersebut dapat dimasukkan dalam tabel Barang utama, nilai tersebut akan disalin ke tabel 'Packing List'."
+DocType: Student Admission,Publish on website,Mempublikasikan di website
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +645,Supplier Invoice Date cannot be greater than Posting Date,Pemasok Faktur Tanggal tidak dapat lebih besar dari Posting Tanggal
 DocType: Purchase Invoice Item,Purchase Order Item,Stok Barang Order Pembelian
+DocType: Agriculture Task,Agriculture Task,Tugas Pertanian
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Pendapatan Tidak Langsung
 DocType: Student Attendance Tool,Student Attendance Tool,Alat Kehadiran Siswa
 DocType: Restaurant Menu,Price List (Auto created),Daftar Harga (Auto dibuat)
@@ -1147,55 +1237,60 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Variance
 ,Company Name,Nama Perusahaan
 DocType: SMS Center,Total Message(s),Total Pesan (s)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +888,Select Item for Transfer,Pilih item untuk transfer
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +913,Select Item for Transfer,Pilih item untuk transfer
 DocType: Purchase Invoice,Additional Discount Percentage,Persentase Diskon Tambahan
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Lihat daftar semua bantuan video
+DocType: Agriculture Analysis Criteria,Soil Texture,Tekstur Tanah
 DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Pilih kepala rekening bank mana cek diendapkan.
 DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Izinkan user/pengguna untuk mengubah rate daftar harga di dalam transaksi
 DocType: Pricing Rule,Max Qty,Qty Maksimum
 apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
 						Please enter a valid Invoice","Row {0}: Faktur {1} tidak valid, mungkin dibatalkan / tidak ada. \ Masukkan Faktur valid"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Baris {0}: Pembayaran terhadap Penjualan / Purchase Order harus selalu ditandai sebagai muka
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +16,Chemical,Kimia
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Baris {0}: Pembayaran terhadap Penjualan / Purchase Order harus selalu ditandai sebagai muka
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Kimia
 DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Default akun Bank / Cash akan secara otomatis diperbarui di Gaji Journal Entri saat mode ini dipilih.
 DocType: BOM,Raw Material Cost(Company Currency),Biaya Bahan Baku (Perusahaan Mata Uang)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +732,All items have already been transferred for this Production Order.,Semua item telah dialihkan untuk Order Produksi ini.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +758,All items have already been transferred for this Production Order.,Semua item telah dialihkan untuk Order Produksi ini.
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Baris # {0}: Tarif tidak boleh lebih besar dari tarif yang digunakan di {1} {2}
-apps/erpnext/erpnext/utilities/user_progress.py +126,Meter,Meter
+apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,Meter
 DocType: Workstation,Electricity Cost,Biaya Listrik
 DocType: HR Settings,Don't send Employee Birthday Reminders,Jangan Kirim Pengingat Ulang Tahun
+DocType: Expense Claim,Total Advance Amount,Jumlah Uang Muka Total
+DocType: Delivery Stop,Estimated Arrival,perkiraan kedatangan
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Simpan Pengaturan
+DocType: Delivery Stop,Notified by Email,Diberitahukan melalui email
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +683,Requested Products,Produk yang diminta
 DocType: Item,Inspection Criteria,Kriteria Inspeksi
 apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Ditransfer
 DocType: BOM Website Item,BOM Website Item,BOM Situs Persediaan
-apps/erpnext/erpnext/public/js/setup_wizard.js +48,Upload your letter head and logo. (you can edit them later).,Unggah kop surat dan logo. (Anda dapat mengubahnya nanti).
+apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Unggah kop surat dan logo. (Anda dapat mengubahnya nanti).
 DocType: Timesheet Detail,Bill,Tagihan
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Berikutnya Penyusutan Tanggal dimasukkan sebagai tanggal terakhir
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +204,White,Putih
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Berikutnya Penyusutan Tanggal dimasukkan sebagai tanggal terakhir
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Putih
 DocType: SMS Center,All Lead (Open),Semua Prospek (Terbuka)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +231,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Row {0}: Qty tidak tersedia untuk {4} di gudang {1} pada postingan kali entri ({2} {3})
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +248,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Row {0}: Qty tidak tersedia untuk {4} di gudang {1} pada postingan kali entri ({2} {3})
 DocType: Purchase Invoice,Get Advances Paid,Dapatkan Uang Muka Dibayar
 DocType: Item,Automatically Create New Batch,Buat Batch Baru secara otomatis
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Make ,Membuat
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Make ,Membuat
 DocType: Student Admission,Admission Start Date,Pendaftaran Mulai Tanggal
 DocType: Journal Entry,Total Amount in Words,Jumlah Total dalam Kata
+apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Karyawan baru
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,Ada kesalahan. Salah satu alasan yang mungkin bisa jadi Anda belum menyimpan formulir. Silahkan hubungi support@erpnext.com jika masalah terus berlanjut.
 apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Cart saya
-apps/erpnext/erpnext/controllers/selling_controller.py +158,Order Type must be one of {0},Order Type harus menjadi salah satu {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +126,Order Type must be one of {0},Order Type harus menjadi salah satu {0}
 DocType: Lead,Next Contact Date,Tanggal Komunikasi Selanjutnya
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Qty Pembukaan
 DocType: Healthcare Settings,Appointment Reminder,Pengingat Penunjukan
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +468,Please enter Account for Change Amount,Silahkan masukkan account untuk Perubahan Jumlah
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +472,Please enter Account for Change Amount,Silahkan masukkan account untuk Perubahan Jumlah
 DocType: Student Batch Name,Student Batch Name,Mahasiswa Nama Batch
 DocType: Consultation,Doctor,Dokter
 DocType: Holiday List,Holiday List Name,Daftar Nama Hari Libur
 DocType: Repayment Schedule,Balance Loan Amount,Saldo Jumlah Pinjaman
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.js +13,Schedule Course,Jadwal Kursus
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +224,Stock Options,Opsi Persediaan
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Jadwal Kursus
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Stock Options,Opsi Persediaan
 DocType: Journal Entry Account,Expense Claim,Biaya Klaim
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +234,Do you really want to restore this scrapped asset?,Apakah Anda benar-benar ingin mengembalikan aset dibuang ini?
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +358,Qty for {0},Kuantitas untuk {0}
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +254,Do you really want to restore this scrapped asset?,Apakah Anda benar-benar ingin mengembalikan aset dibuang ini?
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +380,Qty for {0},Kuantitas untuk {0}
 DocType: Leave Application,Leave Application,Aplikasi Cuti
 DocType: Patient,Patient Relation,Hubungan Pasien
 apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Alat Alokasi Cuti
@@ -1211,18 +1306,22 @@
 apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Tentukan {0}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Removed items with no change in quantity or value.,Item dihapus dengan tidak ada perubahan dalam jumlah atau nilai.
 DocType: Delivery Note,Delivery To,Pengiriman Untuk
-apps/erpnext/erpnext/stock/doctype/item/item.py +682,Attribute table is mandatory,Tabel atribut wajib
+apps/erpnext/erpnext/stock/doctype/item/item.js +384,Variant creation has been queued.,Pembuatan varian telah antri.
+apps/erpnext/erpnext/stock/doctype/item/item.py +668,Attribute table is mandatory,Tabel atribut wajib
 DocType: Production Planning Tool,Get Sales Orders,Dapatkan Order Penjualan
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} tidak dapat negatif
 DocType: Training Event,Self-Study,Belajar sendiri
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +480,Discount,Diskon
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +537,Discount,Diskon
+DocType: Membership,Membership,Keanggotaan
 DocType: Asset,Total Number of Depreciations,Total Jumlah Penyusutan
 DocType: Sales Invoice Item,Rate With Margin,Tingkat Dengan Margin
 DocType: Workstation,Wages,Upah
-DocType: Task,Urgent,Mendesak
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +157,Please specify a valid Row ID for row {0} in table {1},Tentukan Row ID berlaku untuk baris {0} dalam tabel {1}
+DocType: Asset Maintenance,Maintenance Manager Name,Nama Manajer Pemeliharaan
+DocType: Agriculture Task,Urgent,Mendesak
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Tentukan Row ID berlaku untuk baris {0} dalam tabel {1}
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Tidak dapat menemukan variabel:
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +664,Please select a field to edit from numpad,Harap pilih bidang yang akan diedit dari numpad
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +723,Please select a field to edit from numpad,Harap pilih bidang yang akan diedit dari numpad
+apps/erpnext/erpnext/stock/doctype/item/item.py +253,Cannot be a fixed asset item as Stock Ledger is created.,Tidak dapat menjadi item aset tetap karena Stock Ledger dibuat.
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Pergi ke Desktop dan mulai menggunakan ERPNext
 DocType: Item,Manufacturer,Pabrikasi
 DocType: Landed Cost Item,Purchase Receipt Item,Nota Penerimaan Stok Barang
@@ -1231,12 +1330,11 @@
 DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Reserved Gudang di Sales Order / Stok Barang Jadi Gudang
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Selling Amount,Nilai Penjualan
 DocType: Repayment Schedule,Interest Amount,Jumlah bunga
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +109,You are the Expense Approver for this record. Please Update the 'Status' and Save,Anda adalah Approver untuk record ini. Silakan Update 'Status' dan Simpan
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +120,You are the Expense Approver for this record. Please Update the 'Status' and Save,Anda adalah Approver untuk record ini. Silakan Update 'Status' dan Simpan
 DocType: Serial No,Creation Document No,Nomor Dokumen
 DocType: Issue,Issue,Masalah / Isu
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Catatan
 DocType: Asset,Scrapped,membatalkan
-apps/erpnext/erpnext/config/stock.py +200,"Attributes for Item Variants. e.g Size, Color etc.","Atribut untuk Item Varian. misalnya Ukuran, Warna dll"
 DocType: Purchase Invoice,Returns,Retur
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP Gudang
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serial ada {0} berada di bawah kontrak pemeliharaan upto {1}
@@ -1245,7 +1343,8 @@
 DocType: Tax Rule,Shipping State,Negara Pengirim
 ,Projected Quantity as Source,Proyeksi Jumlah sebagai Sumber
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,Item harus ditambahkan dengan menggunakan 'Dapatkan Produk dari Pembelian Penerimaan' tombol
-DocType: Employee,A-,A-
+DocType: Delivery Trip,Delivery Trip,Perjalanan pengiriman
+DocType: Student,A-,A-
 DocType: Production Planning Tool,Include non-stock items,Termasuk item non-persediaan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Beban Penjualan
 DocType: Consultation,Diagnosis,Diagnosa
@@ -1253,8 +1352,8 @@
 DocType: GL Entry,Against,Terhadap
 DocType: Item,Default Selling Cost Center,Standar Pusat Biaya Jual
 DocType: Sales Partner,Implementation Partner,Mitra Implementasi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1598,ZIP Code,Kode Pos
-apps/erpnext/erpnext/controllers/selling_controller.py +271,Sales Order {0} is {1},Sales Order {0} adalah {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1613,ZIP Code,Kode Pos
+apps/erpnext/erpnext/controllers/selling_controller.py +245,Sales Order {0} is {1},Sales Order {0} adalah {1}
 DocType: Opportunity,Contact Info,Informasi Kontak
 apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Membuat Entri Persediaan
 DocType: Packing Slip,Net Weight UOM,Uom Berat Bersih
@@ -1266,40 +1365,45 @@
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Tanggal Berakhir tidak boleh lebih awal dari Tanggal Mulai
 DocType: Sales Person,Select company name first.,Pilih nama perusahaan terlebih dahulu.
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +181,Low to High,Rendah ke tinggi
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +202,Email sent to {0},Email dikirim ke {0}
 apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Penawaran Diterima dari Supplier
 apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Ganti BOM dan update harga terbaru di semua BOM
 apps/erpnext/erpnext/controllers/selling_controller.py +24,To {0} | {1} {2},Untuk {0} | {1} {2}
+DocType: Delivery Trip,Driver Name,Nama pengemudi
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Rata-rata Usia
-DocType: School Settings,Attendance Freeze Date,Tanggal Pembekuan Kehadiran
-apps/erpnext/erpnext/utilities/user_progress.py +89,List a few of your suppliers. They could be organizations or individuals.,Daftar beberapa Supplier Anda. Mereka bisa menjadi organisasi atau individu.
+DocType: Education Settings,Attendance Freeze Date,Tanggal Pembekuan Kehadiran
+apps/erpnext/erpnext/utilities/user_progress.py +107,List a few of your suppliers. They could be organizations or individuals.,Daftar beberapa Supplier Anda. Mereka bisa menjadi organisasi atau individu.
 apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Lihat Semua Produk
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimum Umur Prospek (Hari)
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +57,All BOMs,semua BOMs
 DocType: Patient,Default Currency,Standar Mata Uang
 DocType: Expense Claim,From Employee,Dari Karyawan
-apps/erpnext/erpnext/controllers/accounts_controller.py +407,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Peringatan: Sistem tidak akan memeriksa overbilling karena jumlahnya untuk Item {0} pada {1} adalah nol
+DocType: Driver,Cellphone Number,Nomor ponsel
+apps/erpnext/erpnext/controllers/accounts_controller.py +451,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Peringatan: Sistem tidak akan memeriksa overbilling karena jumlahnya untuk Item {0} pada {1} adalah nol
 DocType: Journal Entry,Make Difference Entry,Buat Entri Perbedaan
 DocType: Upload Attendance,Attendance From Date,Absensi Kehadiran dari Tanggal
 DocType: Appraisal Template Goal,Key Performance Area,Area Kinerja Kunci
 DocType: Program Enrollment,Transportation,Transportasi
 apps/erpnext/erpnext/controllers/item_variant.py +92,Invalid Attribute,Atribut yang tidak valid
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +229,{0} {1} must be submitted,{0} {1} harus di-posting
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +229,{0} {1} must be submitted,{0} {1} harus dikirim
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +151,Quantity must be less than or equal to {0},Kuantitas harus kurang dari atau sama dengan {0}
 DocType: SMS Center,Total Characters,Jumlah Karakter
+DocType: Employee Advance,Claimed,Diklaim
+DocType: Crop,Row Spacing,Row Spacing
 apps/erpnext/erpnext/controllers/buying_controller.py +161,Please select BOM in BOM field for Item {0},Silakan pilih BOM BOM di lapangan untuk Item {0}
 DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktur Detil
 DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Rekonsiliasi Faktur Pembayaran
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Kontribusi%
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +212,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Sesuai dengan Setelan Pembelian jika Pesanan Pembelian Diperlukan == &#39;YA&#39;, maka untuk membuat Purchase Invoice, pengguna harus membuat Purchase Order terlebih dahulu untuk item {0}"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Sesuai dengan Setelan Pembelian jika Pesanan Pembelian Diperlukan == &#39;YA&#39;, maka untuk membuat Purchase Invoice, pengguna harus membuat Purchase Order terlebih dahulu untuk item {0}"
 DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Nomor registrasi perusahaan untuk referensi Anda. Nomor pajak dll
 DocType: Sales Partner,Distributor,Distributor
 DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Aturan Pengiriman Belanja Shoping Cart
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +233,Production Order {0} must be cancelled before cancelling this Sales Order,Order produksi {0} harus dibatalkan sebelum membatalkan Sales Order ini
-apps/erpnext/erpnext/public/js/controllers/transaction.js +68,Please set 'Apply Additional Discount On',Silahkan mengatur &#39;Terapkan Diskon tambahan On&#39;
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Production Order {0} must be cancelled before cancelling this Sales Order,Order produksi {0} harus dibatalkan sebelum membatalkan Sales Order ini
+apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Silahkan mengatur &#39;Terapkan Diskon tambahan On&#39;
 ,Ordered Items To Be Billed,Item Pesanan Tertagih
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Dari Rentang harus kurang dari Untuk Rentang
 DocType: Global Defaults,Global Defaults,Standar Global
-apps/erpnext/erpnext/projects/doctype/project/project.py +215,Project Collaboration Invitation,Proyek Kolaborasi Undangan
+apps/erpnext/erpnext/projects/doctype/project/project.py +226,Project Collaboration Invitation,Proyek Kolaborasi Undangan
 DocType: Salary Slip,Deductions,Pengurangan
 DocType: Leave Allocation,LAL/,LAL /
 DocType: Setup Progress Action,Action Name,Nama Aksi
@@ -1307,49 +1411,51 @@
 apps/erpnext/erpnext/regional/india/utils.py +24,First 2 digits of GSTIN should match with State number {0},2 digit pertama GSTIN harus sesuai dengan nomor Negara {0}
 DocType: Purchase Invoice,Start date of current invoice's period,Tanggal faktur periode saat ini mulai
 DocType: Salary Slip,Leave Without Pay,Cuti Tanpa Bayar
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,Capacity Planning Error,Kesalahan Perencanaan Kapasitas
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,Kesalahan Perencanaan Kapasitas
 ,Trial Balance for Party,Trial Balance untuk Partai
 DocType: Lead,Consultant,Konsultan
 DocType: Salary Slip,Earnings,Pendapatan
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +391,Finished Item {0} must be entered for Manufacture type entry,Selesai Stok Barang {0} harus dimasukkan untuk jenis Produksi entri
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +416,Finished Item {0} must be entered for Manufacture type entry,Selesai Stok Barang {0} harus dimasukkan untuk jenis Produksi entri
 apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Saldo Pembukaan Akuntansi
 ,GST Sales Register,Daftar Penjualan GST
 DocType: Sales Invoice Advance,Sales Invoice Advance,Uang Muka Faktur Penjualan
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Nothing to request,Tidak ada Permintaan
+apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Pilih Domain Anda
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},record Anggaran lain &#39;{0}&#39; sudah ada terhadap {1} &#39;{2}&#39; untuk tahun fiskal {3}
-apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date','Tanggal Mulai Sebenarnya' tidak dapat lebih besar dari 'Tanggal Selesai Sebenarnya'
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +113,Management,Manajemen
+DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Fields akan disalin hanya pada saat penciptaan.
+apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date','Tanggal Mulai Sebenarnya' tidak bisa lebih besar dari 'Tanggal Selesai Sebenarnya'
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Manajemen
 DocType: Cheque Print Template,Payer Settings,Pengaturan Wajib
 DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Ini akan ditambahkan ke Item Code dari varian. Sebagai contoh, jika Anda adalah singkatan ""SM"", dan kode Stok Barang adalah ""T-SHIRT"", kode item varian akan ""T-SHIRT-SM"""
 DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Pay Bersih (dalam kata-kata) akan terlihat setelah Anda menyimpan Slip Gaji.
 DocType: Purchase Invoice,Is Return,Retur Barang
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +80,Caution,Peringatan
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +787,Return / Debit Note,Nota Retur / Debit
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,Caution,Peringatan
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,Return / Debit Note,Nota Retur / Debit
 DocType: Price List Country,Price List Country,Negara Daftar Harga
 DocType: Item,UOMs,UOMs
-apps/erpnext/erpnext/stock/utils.py +205,{0} valid serial nos for Item {1},{0} nomor seri berlaku untuk Item {1}
+apps/erpnext/erpnext/stock/utils.py +210,{0} valid serial nos for Item {1},{0} nomor seri berlaku untuk Item {1}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Item Code tidak dapat diubah untuk Serial Number
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +26,POS Profile {0} already created for user: {1} and company {2},POS Profil {0} sudah dibuat untuk pengguna: {1} dan perusahaan {2}
-DocType: Sales Invoice Item,UOM Conversion Factor,Faktor Konversi UOM
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +23,Please enter Item Code to get Batch Number,Masukkan Item Code untuk mendapatkan Nomor Batch
+DocType: Purchase Invoice Item,UOM Conversion Factor,Faktor Konversi UOM
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Masukkan Item Code untuk mendapatkan Nomor Batch
 DocType: Stock Settings,Default Item Group,Standar Item Grup
 DocType: Employee Loan,Partially Disbursed,sebagian Dicairkan
+apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Berikan informasi.
 apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Database Supplier.
 DocType: Account,Balance Sheet,Neraca
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +701,Cost Center For Item with Item Code ',Biaya Center For Stok Barang dengan Item Code '
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +748,Cost Center For Item with Item Code ',Biaya Center For Stok Barang dengan Item Code '
 DocType: Fee Validity,Valid Till,Berlaku sampai
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2454,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Modus pembayaran tidak dikonfigurasi. Silakan periksa, apakah akun telah ditetapkan pada Cara Pembayaran atau POS Profil."
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2473,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Modus pembayaran tidak dikonfigurasi. Silakan periksa, apakah akun telah ditetapkan pada Cara Pembayaran atau POS Profil."
 apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,item yang sama tidak dapat dimasukkan beberapa kali.
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Further accounts can be made under Groups, but entries can be made against non-Groups","Account lebih lanjut dapat dibuat di bawah Grup, tapi entri dapat dilakukan terhadap non-Grup"
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups","Account lebih lanjut dapat dibuat di bawah Grup, tapi entri dapat dilakukan terhadap non-Grup"
 DocType: Lead,Lead,Prospek
 DocType: Email Digest,Payables,Hutang
 DocType: Course,Course Intro,tentu saja Intro
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Silakan setup seri penomoran untuk Kehadiran melalui Setup&gt; Numbering Series
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +90,Stock Entry {0} created,Entri Persediaan {0} dibuat
-apps/erpnext/erpnext/controllers/buying_controller.py +297,Row #{0}: Rejected Qty can not be entered in Purchase Return,Baris # {0}: Jumlah yang ditolak tidak dapat dimasukkan dalam Retur Pembelian
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +97,Stock Entry {0} created,Entri Persediaan {0} dibuat
+apps/erpnext/erpnext/controllers/buying_controller.py +298,Row #{0}: Rejected Qty can not be entered in Purchase Return,Baris # {0}: Jumlah yang ditolak tidak dapat dimasukkan dalam Retur Pembelian
 ,Purchase Order Items To Be Billed,Purchase Order Items Akan Ditagih
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Updating estimated arrival times.,Memperbarui perkiraan waktu kedatangan.
 DocType: Purchase Invoice Item,Net Rate,Nilai Bersih / Net
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +151,Please select a customer,Silahkan pilih pelanggan
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +147,Please select a customer,Silahkan pilih pelanggan
 DocType: Purchase Invoice Item,Purchase Invoice Item,Stok Barang Faktur Pembelian
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Entri Buku Persediaan dan Entri GL diposting ulang untuk Nota Pembelian yang dipilih
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Item 1
@@ -1362,28 +1468,31 @@
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Order Count
 DocType: Global Defaults,Current Fiscal Year,Tahun Anggaran saat ini
 DocType: Purchase Order,Group same items,Kelompok item yang sama
-DocType: Global Defaults,Disable Rounded Total,Nonaktifkan Pembulatan Jumlah
+DocType: Purchase Invoice,Disable Rounded Total,Nonaktifkan Pembulatan Jumlah
 DocType: Employee Loan Application,Repayment Info,Info pembayaran
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,'Entries' tidak boleh kosong
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +446,'Entries' cannot be empty,'Entries' tidak boleh kosong
+DocType: Maintenance Team Member,Maintenance Role,Peran Pemeliharaan
 apps/erpnext/erpnext/utilities/transaction_base.py +81,Duplicate row {0} with same {1},Baris duplikat {0} dengan sama {1}
 ,Trial Balance,Trial Balance
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +449,Fiscal Year {0} not found,Tahun fiskal {0} tidak ditemukan
-apps/erpnext/erpnext/config/hr.py +300,Setting up Employees,Persiapan Karyawan
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Tahun fiskal {0} tidak ditemukan
+apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Persiapan Karyawan
 DocType: Sales Order,SO-,BEGITU-
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,Silakan pilih awalan terlebih dahulu
-DocType: Employee,O-,HAI-
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +185,Research,Penelitian
+DocType: Student,O-,HAI-
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Penelitian
 DocType: Maintenance Visit Purpose,Work Done,Pekerjaan Selesai
 apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,Silakan tentukan setidaknya satu atribut dalam tabel Atribut
 DocType: Announcement,All Students,Semua murid
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Barang {0} harus barang non-persediaan
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Barang {0} harus barang non-persediaan
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Lihat Buku Besar
 DocType: Grading Scale,Intervals,interval
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Paling Awal
-apps/erpnext/erpnext/stock/doctype/item/item.py +519,"An Item Group exists with same name, please change the item name or rename the item group","Item Grup ada dengan nama yang sama, ubah nama item atau mengubah nama kelompok Stok Barang"
-apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Mahasiswa Nomor Ponsel
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +367,Rest Of The World,Rest of The World
+apps/erpnext/erpnext/stock/doctype/item/item.py +500,"An Item Group exists with same name, please change the item name or rename the item group","Item Grup ada dengan nama yang sama, ubah nama item atau mengubah nama kelompok Stok Barang"
+DocType: Crop Cycle,Less than a year,Kurang dari setahun
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Mahasiswa Nomor Ponsel
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Rest of The World
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Item {0} tidak dapat memiliki Batch
+DocType: Crop,Yield UOM,Hasil UOM
 ,Budget Variance Report,Laporan Perbedaan Anggaran
 DocType: Salary Slip,Gross Pay,Nilai Gross Bayar
 DocType: Item,Is Item from Hub,Adalah Item dari Hub
@@ -1402,7 +1511,6 @@
 DocType: Student,STUD.,STUD.
 DocType: Production Order,Qty To Manufacture,Kuantitas untuk diproduksi
 DocType: Email Digest,New Income,Penghasilan baru
-DocType: School Settings,School Settings,Pengaturan Sekolah
 DocType: Buying Settings,Maintain same rate throughout purchase cycle,Pertahankan tarif yang sama sepanjang siklus pembelian
 DocType: Opportunity Item,Opportunity Item,Peluang Stok Barang
 ,Student and Guardian Contact Details,Mahasiswa dan Wali Detail Kontak
@@ -1414,26 +1522,27 @@
 DocType: Patient Appointment,More Info,Info Selengkapnya
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +178,Valuation Rate required for Item in row {0},Penilaian Tingkat diperlukan untuk Item berturut-turut {0}
 DocType: Supplier Scorecard,Scorecard Actions,Tindakan Scorecard
-apps/erpnext/erpnext/utilities/user_progress.py +148,Example: Masters in Computer Science,Contoh: Magister Ilmu Komputer
+apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Contoh: Magister Ilmu Komputer
 DocType: Purchase Invoice,Rejected Warehouse,Gudang Reject
 DocType: GL Entry,Against Voucher,Terhadap Voucher
 DocType: Item,Default Buying Cost Center,Standar Biaya Pusat Pembelian
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Untuk mendapatkan yang terbaik dari ERPNext, kami menyarankan Anda mengambil beberapa waktu dan menonton video ini membantu."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +74, to ,untuk
+apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,untuk
 DocType: Supplier Quotation Item,Lead Time in days,Masa Tenggang dalam hari
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Ringkasan Buku Besar Hutang
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +337,Payment of salary from {0} to {1},Pembayaran gaji dari {0} ke {1}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},Pembayaran gaji dari {0} ke {1}
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Tidak berwenang untuk mengedit Akun frozen {0}
 DocType: Journal Entry,Get Outstanding Invoices,Dapatkan Faktur Berjalan
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +70,Sales Order {0} is not valid,Order Penjualan {0} tidak valid
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Order Penjualan {0} tidak valid
 DocType: Supplier Scorecard,Warn for new Request for Quotations,Peringatkan untuk Permintaan Kuotasi baru
 apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,pesanan pembelian membantu Anda merencanakan dan menindaklanjuti pembelian Anda
-apps/erpnext/erpnext/setup/doctype/company/company.py +218,"Sorry, companies cannot be merged","Maaf, perusahaan tidak dapat digabungkan"
+apps/erpnext/erpnext/setup/doctype/company/company.py +215,"Sorry, companies cannot be merged","Maaf, perusahaan tidak dapat digabungkan"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Resep Uji Lab
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +162,"The total Issue / Transfer quantity {0} in Material Request {1}  \
 							cannot be greater than requested quantity {2} for Item {3}",Total Issue / transfer kuantitas {0} Material Permintaan {1} \ tidak dapat lebih besar dari yang diminta kuantitas {2} untuk Item {3}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +193,Small,Kecil
-DocType: Employee,Employee Number,Jumlah Karyawan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,Kecil
+DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Membuka Item Alat Pembuatan Faktur
+DocType: Education Settings,Employee Number,Jumlah Karyawan
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Kasus ada (s) sudah digunakan. Coba dari Case ada {0}
 DocType: Project,% Completed,Selesai %
 ,Invoiced Amount (Exculsive Tax),Faktur Jumlah (Pajak exculsive)
@@ -1443,17 +1552,20 @@
 DocType: Item,Auto re-order,Auto re-order
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Total Dicapai
 DocType: Employee,Place of Issue,Tempat Issue
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +97,Contract,Kontrak
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Kontrak
+DocType: Plant Analysis,Laboratory Testing Datetime,Uji Laboratorium Datetime
 DocType: Email Digest,Add Quote,Tambahkan Kutipan
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +869,UOM coversion factor required for UOM: {0} in Item: {1},Faktor coversion UOM diperlukan untuk UOM: {0} di Item: {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +932,UOM coversion factor required for UOM: {0} in Item: {1},Faktor coversion UOM diperlukan untuk UOM: {0} di Item: {1}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Biaya tidak langsung
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Row {0}: Qty is mandatory,Row {0}: Qty adalah wajib
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Pertanian
-apps/erpnext/erpnext/accounts/page/pos/pos.js +770,Sync Master Data,Sync Master Data
-apps/erpnext/erpnext/utilities/user_progress.py +117,Your Products or Services,Produk atau Jasa Anda
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Row {0}: Qty is mandatory,Row {0}: Qty adalah wajib
+DocType: Agriculture Analysis Criteria,Agriculture,Pertanian
+apps/erpnext/erpnext/accounts/page/pos/pos.js +785,Sync Master Data,Sync Master Data
+DocType: Asset Repair,Repair Cost,Biaya perbaikan
+apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Produk atau Jasa Anda
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Gagal untuk masuk
 DocType: Special Test Items,Special Test Items,Item Uji Khusus
 DocType: Mode of Payment,Mode of Payment,Mode Pembayaran
-apps/erpnext/erpnext/stock/doctype/item/item.py +190,Website Image should be a public file or website URL,Website Image harus file umum atau URL situs
+apps/erpnext/erpnext/stock/doctype/item/item.py +192,Website Image should be a public file or website URL,Website Image harus file umum atau URL situs
 DocType: Student Applicant,AP,AP
 DocType: Purchase Invoice Item,BOM,BOM
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Ini adalah kelompok Stok Barang akar dan tidak dapat diedit.
@@ -1461,49 +1573,52 @@
 DocType: Vehicle,Fuel UOM,BBM UOM
 DocType: Warehouse,Warehouse Contact Info,Info Kontak Gudang
 DocType: Payment Entry,Write Off Difference Amount,Menulis Off Perbedaan Jumlah
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +415,"{0}: Employee email not found, hence email not sent","{0}: email Karyawan tidak ditemukan, maka email tidak dikirim"
+DocType: Volunteer,Volunteer Name,Nama Relawan
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: email Karyawan tidak ditemukan, maka email tidak dikirim"
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Aturan pengiriman tidak berlaku untuk negara {0}
 DocType: Item,Foreign Trade Details,Rincian Perdagangan Luar Negeri
 ,Assessment Plan Status,Status Rencana Penilaian
 DocType: Email Digest,Annual Income,Pendapatan tahunan
 DocType: Serial No,Serial No Details,Nomor Detail Serial
 DocType: Purchase Invoice Item,Item Tax Rate,Tarif Pajak Stok Barang
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +67,Please select Physician and Date,Silakan pilih Dokter dan Tanggal
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Silakan pilih Dokter dan Tanggal
 DocType: Student Group Student,Group Roll Number,Nomor roll grup
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry","Untuk {0}, hanya rekening kredit dapat dihubungkan dengan entri debit lain"
-apps/erpnext/erpnext/projects/doctype/project/project.py +78,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Total semua bobot tugas harus 1. Sesuaikan bobot dari semua tugas Proyek sesuai
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +578,Delivery Note {0} is not submitted,Nota pengiriman {0} tidak Terkirim
-apps/erpnext/erpnext/stock/get_item_details.py +151,Item {0} must be a Sub-contracted Item,Item {0} harus Item Sub-kontrak
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +143,"For {0}, only credit accounts can be linked against another debit entry","Untuk {0}, hanya rekening kredit dapat dihubungkan dengan entri debit lain"
+apps/erpnext/erpnext/projects/doctype/project/project.py +80,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Total semua bobot tugas harus 1. Sesuaikan bobot dari semua tugas Proyek sesuai
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +582,Delivery Note {0} is not submitted,Nota pengiriman {0} tidak Terkirim
+apps/erpnext/erpnext/stock/get_item_details.py +146,Item {0} must be a Sub-contracted Item,Item {0} harus Item Sub-kontrak
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Perlengkapan Modal
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Rule harga terlebih dahulu dipilih berdasarkan 'Terapkan On' lapangan, yang dapat Stok Barang, Stok Barang Grup atau Merek."
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +223,Please set the Item Code first,Harap set Kode Item terlebih dahulu
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +245,Please set the Item Code first,Harap set Kode Item terlebih dahulu
 DocType: Item,ITEM-,BARANG-
-apps/erpnext/erpnext/controllers/selling_controller.py +151,Total allocated percentage for sales team should be 100,Persentase total yang dialokasikan untuk tim penjualan harus 100
+apps/erpnext/erpnext/controllers/selling_controller.py +119,Total allocated percentage for sales team should be 100,Persentase total yang dialokasikan untuk tim penjualan harus 100
 DocType: Sales Invoice Item,Edit Description,Edit Keterangan
 DocType: Antibiotic,Antibiotic,Antibiotika
 ,Team Updates,tim Pembaruan
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +885,For Supplier,Untuk Supplier
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +910,For Supplier,Untuk Supplier
 DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Mengatur Tipe Akun membantu dalam memilih Akun ini dalam transaksi.
 DocType: Purchase Invoice,Grand Total (Company Currency),Jumlah Nilai Total (Mata Uang Perusahaan)
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Buat Print Format
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Biaya Dibuat
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Biaya Dibuat
 apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Tidak menemukan item yang disebut {0}
 DocType: Supplier Scorecard Criteria,Criteria Formula,Formula Kriteria
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Total Outgoing
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +47,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Hanya ada satu Peraturan Pengiriman Kondisi dengan nilai kosong atau 0 untuk ""To Nilai"""
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Hanya ada satu Peraturan Pengiriman Kondisi dengan nilai kosong atau 0 untuk ""To Nilai"""
 DocType: Authorization Rule,Transaction,Transaksi
 DocType: Patient Appointment,Duration,Lamanya
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Catatan: Biaya Pusat ini adalah Group. Tidak bisa membuat entri akuntansi terhadap kelompok-kelompok.
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,gudang anak ada untuk gudang ini. Anda tidak dapat menghapus gudang ini.
 DocType: Item,Website Item Groups,Situs Grup Stok Barang
 DocType: Purchase Invoice,Total (Company Currency),Total (Perusahaan Mata Uang)
-apps/erpnext/erpnext/stock/utils.py +200,Serial number {0} entered more than once,Serial number {0} masuk lebih dari sekali
-DocType: Depreciation Schedule,Journal Entry,Jurnal Entri
+apps/erpnext/erpnext/stock/utils.py +205,Serial number {0} entered more than once,Serial number {0} masuk lebih dari sekali
+DocType: Journal Entry,Journal Entry,Jurnal Entri
+DocType: Expense Claim Advance,Unclaimed amount,Jumlah yang tidak diklaim
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,{0} item berlangsung
 DocType: Workstation,Workstation Name,Nama Workstation
 DocType: Grading Scale Interval,Grade Code,Kode kelas
 DocType: POS Item Group,POS Item Group,POS Barang Grup
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Surel Ringkasan:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +587,BOM {0} does not belong to Item {1},BOM {0} bukan milik Produk {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +591,BOM {0} does not belong to Item {1},BOM {0} bukan milik Produk {1}
 DocType: Sales Partner,Target Distribution,Target Distribusi
 DocType: Salary Slip,Bank Account No.,No Rekening Bank
 DocType: Naming Series,This is the number of the last created transaction with this prefix,Ini adalah jumlah transaksi yang diciptakan terakhir dengan awalan ini
@@ -1518,11 +1633,11 @@
 DocType: BOM Operation,Workstation,Workstation
 DocType: Request for Quotation Supplier,Request for Quotation Supplier,Permintaan Quotation Pemasok
 DocType: Healthcare Settings,Registration Message,Pesan Pendaftaran
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +150,Hardware,Perangkat keras
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Perangkat keras
 DocType: Prescription Dosage,Prescription Dosage,Dosis Resep
 DocType: Attendance,HR Manager,HR Manager
-apps/erpnext/erpnext/accounts/party.py +177,Please select a Company,Silakan pilih sebuah Perusahaan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Privilege Leave,Privilege Cuti
+apps/erpnext/erpnext/accounts/party.py +178,Please select a Company,Silakan pilih sebuah Perusahaan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Privilege Cuti
 DocType: Purchase Invoice,Supplier Invoice Date,Tanggal Faktur Supplier
 apps/erpnext/erpnext/templates/includes/product_page.js +18,per,per
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Anda harus mengaktifkan Keranjang Belanja
@@ -1534,7 +1649,7 @@
 ,BOM Browser,BOM Browser
 apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Harap perbarui status Anda untuk acara pelatihan ini
 DocType: Purchase Taxes and Charges,Add or Deduct,Penambahan atau Pengurangan
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +82,Overlapping conditions found between:,Kondisi Tumpang Tindih ditemukan antara:
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Kondisi Tumpang Tindih ditemukan antara:
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Atas Catatan Jurnal {0} sudah dilakukan penyesuaian terhadap beberapa dokumen lain.
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Nilai Total Order
 apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,Makanan
@@ -1542,7 +1657,7 @@
 DocType: Maintenance Schedule Item,No of Visits,Tidak ada Kunjungan
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Jadwal Pemeliharaan {0} ada terhadap {1}
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +118,Do you want to publish your Items to Hub ?,Ingin menerbitkan Item ke Hub?
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +36,Enrolling student,mahasiswa Mendaftarkan
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,mahasiswa Mendaftarkan
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Mata uang dari Rekening Penutupan harus {0}
 apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Jumlah poin untuk semua tujuan harus 100. Ini adalah {0}
 DocType: Project,Start and End Dates,Mulai dan Akhir Tanggal
@@ -1554,7 +1669,7 @@
 DocType: Rename Tool,Utilities,Utilitas
 DocType: POS Profile,Accounting,Akuntansi
 DocType: Employee,EMP/,EMP /
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +123,Please select batches for batched item ,Silakan pilih batch untuk item batched
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Silakan pilih batch untuk item batched
 DocType: Asset,Depreciation Schedules,Jadwal penyusutan
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Periode aplikasi tidak bisa periode alokasi cuti di luar
 DocType: Activity Cost,Projects,Proyek
@@ -1567,7 +1682,7 @@
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Rata-rata Harian Outgoing
 DocType: POS Profile,Campaign,Promosi
 DocType: Supplier,Name and Type,Nama dan Jenis
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +64,Approval Status must be 'Approved' or 'Rejected',Status Persetujuan harus 'Disetujui' atau 'Ditolak'
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +66,Approval Status must be 'Approved' or 'Rejected',Status Persetujuan harus 'Disetujui' atau 'Ditolak'
 DocType: Physician,Contacts and Address,Kontak dan Alamat
 DocType: Purchase Invoice,Contact Person,Contact Person
 apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date',"""Jadwal Tanggal Mulai' tidak dapat lebih besar dari 'Jadwal Tanggal Selesai'"
@@ -1575,14 +1690,15 @@
 DocType: Holiday List,Holidays,Hari Libur
 DocType: Sales Order Item,Planned Quantity,Direncanakan Kuantitas
 DocType: Purchase Invoice Item,Item Tax Amount,Jumlah Pajak Stok Barang
+DocType: Water Analysis,Water Analysis Criteria,Kriteria Analisis Air
 DocType: Item,Maintain Stock,Jaga Persediaan
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +212,Stock Entries already created for Production Order ,Entri Persediaan sudah dibuat untuk Perintah Produksi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217,Stock Entries already created for Production Order ,Entri Persediaan sudah dibuat untuk Perintah Produksi
 DocType: Employee,Prefered Email,Email Utama
 DocType: Student Admission,Eligibility and Details,Kelayakan dan Detail
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Perubahan bersih dalam Aset Tetap
 DocType: Leave Control Panel,Leave blank if considered for all designations,Biarkan kosong jika dipertimbangkan untuk semua sebutan
-apps/erpnext/erpnext/controllers/accounts_controller.py +663,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Mengisi tipe 'sebenarnya' berturut-turut {0} tidak dapat dimasukkan dalam Butir Tingkat
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +359,Max: {0},Max: {0}
+apps/erpnext/erpnext/controllers/accounts_controller.py +775,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Mengisi tipe 'sebenarnya' berturut-turut {0} tidak dapat dimasukkan dalam Butir Tingkat
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Max: {0},Max: {0}
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Dari Datetime
 DocType: Email Digest,For Company,Untuk Perusahaan
 apps/erpnext/erpnext/config/support.py +17,Communication log.,Log komunikasi.
@@ -1591,18 +1707,19 @@
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +73,Buying Amount,Jumlah Pembelian
 DocType: Sales Invoice,Shipping Address Name,Alamat Pengiriman
 DocType: Material Request,Terms and Conditions Content,Syarat dan Ketentuan Konten
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +555,cannot be greater than 100,tidak dapat lebih besar dari 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +734,Item {0} is not a stock Item,Barang {0} bukan merupakan Barang persediaan
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Ada kesalahan dalam membuat Jadwal Kursus
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +580,cannot be greater than 100,tidak dapat lebih besar dari 100
+apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item {0} is not a stock Item,Barang {0} bukan merupakan Barang persediaan
 DocType: Maintenance Visit,Unscheduled,Tidak Terjadwal
 DocType: Employee,Owned,Dimiliki
 DocType: Salary Detail,Depends on Leave Without Pay,Tergantung pada Cuti Tanpa Bayar
 DocType: Pricing Rule,"Higher the number, higher the priority","Semakin tinggi angkanya, semakin tinggi prioritas"
 ,Purchase Invoice Trends,Pembelian Faktur Trends
 DocType: Employee,Better Prospects,Prospek yang Lebih Baik
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +115,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Baris # {0}: Kumpulan {1} hanya memiliki {2} qty. Silakan pilih batch lain yang memiliki {3} qty available atau membagi baris menjadi beberapa baris, untuk mengirimkan / mengeluarkan dari beberapa batch"
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Baris # {0}: Kumpulan {1} hanya memiliki {2} qty. Silakan pilih batch lain yang memiliki {3} qty available atau membagi baris menjadi beberapa baris, untuk mengirimkan / mengeluarkan dari beberapa batch"
 DocType: Vehicle,License Plate,Pelat
 DocType: Appraisal,Goals,tujuan
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +326,Select POS Profile,Pilih Profil POS
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +343,Select POS Profile,Pilih Profil POS
 DocType: Warranty Claim,Warranty / AMC Status,Garansi / Status AMC
 ,Accounts Browser,Browser Nama Akun
 DocType: Payment Entry Reference,Payment Entry Reference,Pembayaran Referensi Masuk
@@ -1611,25 +1728,28 @@
 ,Batch-Wise Balance History,Rekap Transaksi Persediaan per Batch
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,pengaturan cetak diperbarui dalam format cetak masing
 DocType: Package Code,Package Code,Kode paket
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +101,Apprentice,Magang
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,Magang
 DocType: Purchase Invoice,Company GSTIN,Perusahaan GSTIN
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Jumlah negatif tidak diperbolehkan
 DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
 Used for Taxes and Charges","Rinci tabel pajak diambil dari master Stok Barang sebagai string dan disimpan dalam bidang ini.
  Digunakan untuk Pajak dan Biaya"
 DocType: Supplier Scorecard Period,SSC-,SSC-
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +154,Employee cannot report to himself.,Karyawan tidak bisa melaporkan kepada dirinya sendiri.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,Karyawan tidak bisa melaporkan kepada dirinya sendiri.
 DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Jika account beku, entri yang diizinkan untuk pengguna terbatas."
 DocType: Email Digest,Bank Balance,Saldo bank
-apps/erpnext/erpnext/accounts/party.py +245,Accounting Entry for {0}: {1} can only be made in currency: {2},Entri Akuntansi untuk {0}: {1} hanya dapat dilakukan dalam mata uang: {2}
+apps/erpnext/erpnext/accounts/party.py +243,Accounting Entry for {0}: {1} can only be made in currency: {2},Entri Akuntansi untuk {0}: {1} hanya dapat dilakukan dalam mata uang: {2}
 DocType: Job Opening,"Job profile, qualifications required etc.","Profil pekerjaan, kualifikasi yang dibutuhkan dll"
 DocType: Journal Entry Account,Account Balance,Saldo Akun Rekening
-apps/erpnext/erpnext/config/accounts.py +191,Tax Rule for transactions.,Aturan pajak untuk transaksi.
+apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Aturan pajak untuk transaksi.
 DocType: Rename Tool,Type of document to rename.,Jenis dokumen untuk mengubah nama.
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Pelanggan diperlukan terhadap akun Piutang {2}
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Pelanggan diperlukan untuk akun Piutang {2}
 DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Jumlah Pajak dan Biaya (Perusahaan Mata Uang)
+DocType: Weather,Weather Parameter,Parameter Cuaca
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Tampilkan P &amp; saldo L tahun fiskal tertutup ini
 DocType: Lab Test Template,Collection Details,Detail Koleksi
+DocType: POS Profile,Allow Print Before Pay,Izinkan Cetak Sebelum Bayar
+DocType: Land Unit,Linked Soil Texture,Tekstur Tanah Tertib
 DocType: Shipping Rule,Shipping Account,Account Pengiriman
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Akun {2} tidak aktif
 apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Membuat Penjualan Pesanan untuk membantu Anda merencanakan pekerjaan Anda dan memberikan tepat waktu
@@ -1637,44 +1757,48 @@
 DocType: Stock Entry,Total Additional Costs,Total Biaya Tambahan
 DocType: Course Schedule,SH,SH
 DocType: BOM,Scrap Material Cost(Company Currency),Scrap Material Cost (Perusahaan Mata Uang)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Sub Assemblies,Sub Assemblies
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Sub Assemblies
 DocType: Asset,Asset Name,Aset Nama
 DocType: Project,Task Weight,tugas Berat
 DocType: Shipping Rule Condition,To Value,Untuk Dinilai
 DocType: Asset Movement,Stock Manager,Pengelola Persediaan
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +144,Source warehouse is mandatory for row {0},Sumber gudang adalah wajib untuk baris {0}
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +809,Packing Slip,Slip Packing
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +149,Source warehouse is mandatory for row {0},Sumber gudang adalah wajib untuk baris {0}
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Syarat Pembayaran di baris {0} mungkin merupakan duplikat.
+apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Pertanian (beta)
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +856,Packing Slip,Slip Packing
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Sewa Kantor
 apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Pengaturan gerbang Pengaturan SMS
+DocType: Disease,Common Name,Nama yang umum
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Impor Gagal!
 apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Belum ditambahkan alamat
 DocType: Workstation Working Hour,Workstation Working Hour,Jam Kerja Workstation
 DocType: Vital Signs,Blood Pressure,Tekanan darah
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +121,Analyst,Analis
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,Analis
 DocType: Item,Inventory,Inventarisasi
 DocType: Item,Sales Details,Detail Penjualan
 DocType: Quality Inspection,QI-,QI-
 DocType: Opportunity,With Items,Dengan Produk
+DocType: Asset Maintenance,Maintenance Team,Tim Pemeliharaan
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,Dalam Qty
-DocType: School Settings,Validate Enrolled Course for Students in Student Group,Validasi Kursus Terdaftar untuk Siswa di Kelompok Pelajar
+DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Validasi Kursus Terdaftar untuk Siswa di Kelompok Pelajar
 DocType: Notification Control,Expense Claim Rejected,Beban Klaim Ditolak
 DocType: Item,Item Attribute,Item Atribut
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +143,Government,pemerintahan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,pemerintahan
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Beban Klaim {0} sudah ada untuk Kendaraan Log
-apps/erpnext/erpnext/public/js/setup_wizard.js +60,Institute Name,nama institusi
+apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,nama institusi
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Masukkan pembayaran Jumlah
 apps/erpnext/erpnext/config/stock.py +305,Item Variants,Item Varian
-DocType: Company,Services,Jasa
+apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Jasa
 DocType: HR Settings,Email Salary Slip to Employee,Email Slip Gaji ke Karyawan
 DocType: Cost Center,Parent Cost Center,Parent Biaya Pusat
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1017,Select Possible Supplier,Pilih Kemungkinan Pemasok
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1039,Select Possible Supplier,Pilih Kemungkinan Pemasok
 DocType: Sales Invoice,Source,Sumber
 apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Tampilkan ditutup
 DocType: Leave Type,Is Leave Without Pay,Apakah Cuti Tanpa Bayar
-apps/erpnext/erpnext/stock/doctype/item/item.py +248,Asset Category is mandatory for Fixed Asset item,Aset Kategori adalah wajib untuk item aset tetap
+apps/erpnext/erpnext/stock/doctype/item/item.py +250,Asset Category is mandatory for Fixed Asset item,Aset Kategori adalah wajib untuk item aset tetap
 DocType: Fee Validity,Fee Validity,Validitas biaya
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,No records found in the Payment table,Tidak ada catatan yang ditemukan dalam tabel Pembayaran
-apps/erpnext/erpnext/schools/utils.py +19,This {0} conflicts with {1} for {2} {3},Ini {0} konflik dengan {1} untuk {2} {3}
+apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Ini {0} konflik dengan {1} untuk {2} {3}
 DocType: Student Attendance Tool,Students HTML,siswa HTML
 DocType: POS Profile,Apply Discount,Terapkan Diskon
 DocType: GST HSN Code,GST HSN Code,Kode HSN GST
@@ -1689,16 +1813,18 @@
 apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Diambil
 DocType: Student,Date of Leaving,Tanggal Meninggalkan
 DocType: Pricing Rule,For Price List,Untuk Daftar Harga
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Pencarian eksekutif
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Pencarian eksekutif
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Pengaturan default
 apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Buat Prospek
 DocType: Maintenance Schedule,Schedules,Jadwal
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +331,POS Profile is required to use Point-of-Sale,Profil POS diharuskan menggunakan Point of Sale
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +451,POS Profile is required to use Point-of-Sale,Profil POS diharuskan menggunakan Point of Sale
 DocType: Purchase Invoice Item,Net Amount,Nilai Bersih
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +138,{0} {1} has not been submitted so the action cannot be completed,{0} {1} belum dikirim sehingga tindakan tidak dapat diselesaikan
 DocType: Purchase Order Item Supplied,BOM Detail No,No. Rincian BOM
 DocType: Landed Cost Voucher,Additional Charges,Pungutan-pungutan tambahan
 DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Jumlah Diskon Tambahan (dalam Mata Uang Perusahaan)
 DocType: Supplier Scorecard,Supplier Scorecard,Supplier Scorecard
+DocType: Plant Analysis,Result Datetime,Hasil Datetime
 apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Silahkan buat akun baru dari Bagan Akun.
 ,Support Hour Distribution,Distribusi Jam Dukungan
 DocType: Maintenance Visit,Maintenance Visit,Kunjungan Pemeliharaan
@@ -1708,10 +1834,12 @@
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Update Format Cetak
 DocType: Landed Cost Voucher,Landed Cost Help,Bantuan Biaya Landed
 DocType: Purchase Invoice,Select Shipping Address,Pilih Alamat Pengiriman
+apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Rincian Memebership
 DocType: Leave Block List,Block Holidays on important days.,Blok Hari Libur pada hari-hari penting.
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Ringkasan Buku Piutang
 DocType: Employee Loan,Monthly Repayment Amount,Bulanan Pembayaran Jumlah
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +191,Please set User ID field in an Employee record to set Employee Role,Silakan set ID lapangan Pengguna dalam catatan Karyawan untuk mengatur Peran Karyawan
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Membuka Faktur
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,Please set User ID field in an Employee record to set Employee Role,Silakan set ID lapangan Pengguna dalam catatan Karyawan untuk mengatur Peran Karyawan
 DocType: UOM,UOM Name,Nama UOM
 DocType: GST HSN Code,HSN Code,Kode HSN
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Jumlah kontribusi
@@ -1719,25 +1847,25 @@
 DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Alat ini membantu Anda memperbarui atau memperbaiki kuantitas dan valuasi persediaan di sistem. Biasanya digunakan untuk menyelaraskan sistem dengan aktual barang yang ada di gudang.
 DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,Dalam Kata-kata akan terlihat sekali Anda menyimpan Delivery Note.
 DocType: Expense Claim,EXP,EXP
-apps/erpnext/erpnext/config/stock.py +205,Brand master.,Master merek.
-apps/erpnext/erpnext/schools/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Mahasiswa {0} - {1} muncul Beberapa kali berturut-turut {2} &amp; {3}
+DocType: Water Analysis,Container,Wadah
+apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Mahasiswa {0} - {1} muncul Beberapa kali berturut-turut {2} &amp; {3}
 DocType: Healthcare Settings,Manage Sample Collection,Mengelola Sampel Koleksi
 DocType: Program Enrollment Tool,Program Enrollments,Program Terdaftar
 DocType: Patient,Tobacco Past Use,Tobacco Past Use
 DocType: Sales Invoice Item,Brand Name,Nama Merek
 DocType: Purchase Receipt,Transporter Details,Detail transporter
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Pengguna {0} sudah ditugaskan ke Dokter {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2638,Default warehouse is required for selected item,gudang standar diperlukan untuk item yang dipilih
-apps/erpnext/erpnext/utilities/user_progress.py +125,Box,Kotak
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1014,Possible Supplier,mungkin Pemasok
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2657,Default warehouse is required for selected item,gudang standar diperlukan untuk item yang dipilih
+apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Kotak
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1036,Possible Supplier,mungkin Pemasok
 DocType: Budget,Monthly Distribution,Distribusi bulanan
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Receiver List kosong. Silakan membuat Receiver List
-apps/erpnext/erpnext/public/js/setup_wizard.js +29,Healthcare (beta),Kesehatan (beta)
+apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Kesehatan (beta)
 DocType: Production Plan Sales Order,Production Plan Sales Order,Rencana Produksi berdasar Order Penjualan
 DocType: Sales Partner,Sales Partner Target,Sasaran Mitra Penjualan
 DocType: Loan Type,Maximum Loan Amount,Maksimum Jumlah Pinjaman
 DocType: Pricing Rule,Pricing Rule,Aturan Harga
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Nomor pengguliran duplikat untuk siswa {0}
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Nomor pengguliran duplikat untuk siswa {0}
 DocType: Budget,Action if Annual Budget Exceeded,Tindakan jika Anggaran Tahunan Melebihi
 apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Permintaan Material untuk Order Pembelian
 DocType: Shopping Cart Settings,Payment Success URL,Pembayaran Sukses URL
@@ -1752,50 +1880,55 @@
 DocType: C-Form,III,AKU AKU AKU
 apps/erpnext/erpnext/config/stock.py +310,Opening Stock Balance,Saldo Persediaan Pembukaan
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} harus muncul hanya sekali
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +368,Not allowed to tranfer more {0} than {1} against Purchase Order {2},Tidak diizinkan untuk tranfer lebih {0} dari {1} terhadap Purchase Order {2}
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},cuti Dialokasikan Berhasil untuk {0}
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Tidak ada item untuk dikemas
 DocType: Shipping Rule Condition,From Value,Dari Nilai
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +555,Manufacturing Quantity is mandatory,Qty Manufaktur  wajib diisi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +581,Manufacturing Quantity is mandatory,Qty Manufaktur  wajib diisi
 DocType: Employee Loan,Repayment Method,Metode pembayaran
 DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Jika diperiksa, Home page akan menjadi default Barang Group untuk website"
 DocType: Quality Inspection Reading,Reading 4,Membaca 4
-apps/erpnext/erpnext/config/hr.py +127,Claims for company expense.,Klaim untuk biaya perusahaan.
+apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Klaim untuk biaya perusahaan.
 apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Siswa di jantung dari sistem, menambahkan semua siswa Anda"
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: tanggal Jarak {1} tidak bisa sebelum Cek Tanggal {2}
+DocType: Asset Maintenance Task,Certificate Required,Sertifikat yang dibutuhkan
 DocType: Company,Default Holiday List,Standar Daftar Hari Libur
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,Row {0}: From Time and To Time of {1} is overlapping with {2},Row {0}: Dari Waktu dan Untuk Waktu {1} adalah tumpang tindih dengan {2}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Hutang Persediaan
 DocType: Purchase Invoice,Supplier Warehouse,Gudang Supplier
 DocType: Opportunity,Contact Mobile No,Kontak Mobile No
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +356,Select Company,Pilih Perusahaan
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +382,Select Company,Pilih Perusahaan
 ,Material Requests for which Supplier Quotations are not created,Permintaan Material yang Supplier Quotation tidak diciptakan
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Pengguna {0} tidak memiliki Profil POS default. Cek Default di Baris {1} untuk Pengguna ini.
 DocType: Student Group,Set 0 for no limit,Set 0 untuk tidak ada batas
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +141,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Hari (s) yang Anda lamar cuti adalah hari libur. Anda tidak perlu mengajukan cuti.
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Baris {idx}: {field} diperlukan untuk membuat Pembukaan {invoice_type} Faktur
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Kirim ulang Email Pembayaran
 apps/erpnext/erpnext/templates/pages/projects.html +27,New task,tugas baru
 DocType: Consultation,Appointment,Janji
 apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Membuat Quotation
 apps/erpnext/erpnext/config/selling.py +216,Other Reports,Laporan lainnya
+apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Pilih setidaknya satu domain.
 DocType: Dependent Task,Dependent Task,Tugas Dependent
-apps/erpnext/erpnext/stock/doctype/item/item.py +414,Conversion factor for default Unit of Measure must be 1 in row {0},Faktor konversi untuk Unit default Ukur harus 1 berturut-turut {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +430,Conversion factor for default Unit of Measure must be 1 in row {0},Faktor konversi untuk Unit default Ukur harus 1 berturut-turut {0}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +208,Leave of type {0} cannot be longer than {1},Cuti jenis {0} tidak boleh lebih dari {1}
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,Coba operasi untuk hari X perencanaan di muka.
 DocType: HR Settings,Stop Birthday Reminders,Stop Pengingat Ulang Tahun
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +250,Please set Default Payroll Payable Account in Company {0},Silahkan mengatur default Payroll Hutang Akun di Perusahaan {0}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Silahkan mengatur default Payroll Hutang Akun di Perusahaan {0}
 DocType: SMS Center,Receiver List,Daftar Penerima
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1068,Search Item,Cari Barang
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1083,Search Item,Cari Barang
+DocType: Payment Schedule,Payment Amount,Jumlah pembayaran
 DocType: Patient Appointment,Referring Physician,Merujuk Dokter
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Dikonsumsi Jumlah
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Perubahan bersih dalam kas
 DocType: Assessment Plan,Grading Scale,Skala penilaian
-apps/erpnext/erpnext/stock/doctype/item/item.py +409,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Satuan Ukur {0} telah dimasukkan lebih dari sekali dalam Faktor Konversi Tabel
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +612,Already completed,Sudah lengkap
+apps/erpnext/erpnext/stock/doctype/item/item.py +425,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Satuan Ukur {0} telah dimasukkan lebih dari sekali dalam Faktor Konversi Tabel
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +616,Already completed,Sudah lengkap
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Persediaan Di Tangan
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Impor Sukses!
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Permintaan pembayaran sudah ada {0}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Biaya Produk Dikeluarkan
 DocType: Physician,Hospital,RSUD
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +362,Quantity must not be more than {0},Kuantitas tidak boleh lebih dari {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +384,Quantity must not be more than {0},Kuantitas tidak boleh lebih dari {0}
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Sebelumnya Keuangan Tahun tidak tertutup
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Umur (Hari)
 DocType: Quotation Item,Quotation Item,Produk/Barang Penawaran
@@ -1805,14 +1938,15 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serial ada {0} kuantitas {1} tak bisa menjadi pecahan
 apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Supplier Type induk.
 DocType: Purchase Order Item,Supplier Part Number,Supplier Part Number
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +105,Conversion rate cannot be 0 or 1,Tingkat konversi tidak bisa 0 atau 1
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Tingkat konversi tidak bisa 0 atau 1
 DocType: Subscription,Reference Document,Dokumen referensi
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +208,{0} {1} is cancelled or stopped,{0} {1} dibatalkan atau dihentikan
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +209,{0} {1} is cancelled or stopped,{0} {1} dibatalkan atau dihentikan
 DocType: Accounts Settings,Credit Controller,Kredit Kontroller
+DocType: Grant Application,Applicant Type,Jenis Pemohon
 DocType: Delivery Note,Vehicle Dispatch Date,Kendaraan Dikirim Tanggal
 DocType: Healthcare Settings,Default Medical Code Standard,Standar Kode Standar Medis
 DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +234,Purchase Receipt {0} is not submitted,Nota Penerimaan {0} tidak Terkirim
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,Nota Penerimaan {0} tidak Terkirim
 DocType: Company,Default Payable Account,Standar Akun Hutang
 apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Pengaturan untuk keranjang belanja online seperti aturan pengiriman, daftar harga dll"
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% Ditagih
@@ -1821,40 +1955,44 @@
 DocType: Party Account,Party Account,Akun Party
 apps/erpnext/erpnext/config/setup.py +122,Human Resources,Sumber Daya Manusia
 DocType: Lead,Upper Income,Penghasilan Atas
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +41,Reject,Menolak
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,Menolak
 DocType: Journal Entry Account,Debit in Company Currency,Debit di Mata Uang Perusahaan
 DocType: BOM Item,BOM Item,Komponen BOM
 DocType: Appraisal,For Employee,Untuk Karyawan
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Membuat Pencairan Masuk
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Row {0}: Muka melawan Supplier harus mendebet
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Supplier must be debit,Row {0}: Muka melawan Supplier harus mendebet
 DocType: Company,Default Values,Nilai Default
+DocType: Membership,INR,INR
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Frekuensi} Digest
 DocType: Expense Claim,Total Amount Reimbursed,Jumlah Total diganti
 apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Hal ini didasarkan pada log terhadap kendaraan ini. Lihat timeline di bawah untuk rincian
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Against Supplier Invoice {0} dated {1},Terhadap Faktur Supplier {0} di tanggal {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Terhadap Faktur Supplier {0} di tanggal {1}
 DocType: Customer,Default Price List,Standar List Harga
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +244,Asset Movement record {0} created,Gerakan aset catatan {0} dibuat
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +265,Asset Movement record {0} created,Gerakan aset catatan {0} dibuat
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Anda tidak dapat menghapus Tahun Anggaran {0}. Tahun Fiskal {0} diatur sebagai default di Pengaturan Global
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Seorang pelanggan dengan nama yang sama sudah ada
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +183,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Ini akan mengirimkan Slip Gaji dan membuat Entri Jurnal akrual. Apakah kamu ingin melanjutkan?
+DocType: Purchase Invoice,Total Net Weight,Total Berat Bersih
 DocType: Journal Entry,Entry Type,Entri Type
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Tidak ada rencana penilaian yang terkait dengan kelompok penilaian ini
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Tidak ada rencana penilaian yang terkait dengan kelompok penilaian ini
 ,Customer Credit Balance,Saldo Kredit Pelanggan
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Perubahan bersih Hutang
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Pelanggan diperlukan untuk 'Diskon Pelanggan'
-apps/erpnext/erpnext/config/accounts.py +148,Update bank payment dates with journals.,Perbarui tanggal pembayaran bank dengan jurnal.
+apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Perbarui tanggal pembayaran bank dengan jurnal.
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,harga
 DocType: Quotation,Term Details,Rincian Term
-DocType: Project,Total Sales Cost (via Sales Order),Total Biaya Penjualan (via Sales Order)
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,tidak bisa mendaftar lebih dari {0} siswa untuk kelompok siswa ini.
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,tidak bisa mendaftar lebih dari {0} siswa untuk kelompok siswa ini.
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Jumlah Prospek
-apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} harus lebih besar dari 0
+apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} harus lebih besar dari 0
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +17,Stock Available,Stok Tersedia
 DocType: Manufacturing Settings,Capacity Planning For (Days),Perencanaan Kapasitas Untuk (Hari)
 apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Pembelian
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,None of the items have any change in quantity or value.,Tak satu pun dari item memiliki perubahan kuantitas atau nilai.
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Bidang wajib - Program
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Bidang wajib - Program
 DocType: Special Test Template,Result Component,Komponen Hasil
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garansi Klaim
 ,Lead Details,Rincian Prospek
+DocType: Volunteer,Availability and Skills,Ketersediaan dan Keterampilan
 DocType: Salary Slip,Loan repayment,Pembayaran pinjaman
 DocType: Purchase Invoice,End date of current invoice's period,Tanggal akhir periode faktur saat ini
 DocType: Pricing Rule,Applicable For,Berlaku Untuk
@@ -1865,14 +2003,14 @@
 DocType: Shipping Rule Country,Shipping Rule Country,Aturan Pengiriman – Negara
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Tinggalkan dan Kehadiran
 DocType: Maintenance Visit,Partially Completed,Selesai Sebagian
-apps/erpnext/erpnext/healthcare/setup.py +256,Moderate Sensitivity,Sensitivitas sedang
+apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Sensitivitas sedang
 DocType: Leave Type,Include holidays within leaves as leaves,Sertakan libur dalam cuti cuti
 DocType: Sales Invoice,Packed Items,Produk Kemasan
 apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garansi Klaim terhadap Serial No.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +65,'Total',&#39;Total&#39;
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +71,'Total',&#39;Total&#39;
 DocType: Shopping Cart Settings,Enable Shopping Cart,Aktifkan Keranjang Belanja
 DocType: Employee,Permanent Address,Alamat Tetap
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +258,"Advance paid against {0} {1} cannot be greater \
 						than Grand Total {2}",Uang muka yang dibayar terhadap {0} {1} tidak dapat lebih besar \ dari Grand Total {2}
 DocType: Patient,Medication,Obat
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Silahkan pilih kode Stok Barang
@@ -1883,36 +2021,42 @@
 DocType: Purchase Invoice,Additional Discount,Potongan Tambahan
 DocType: Selling Settings,Selling Settings,Pengaturan Penjualan
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Konfirmasi Tindakan
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +39,Online Auctions,Lelang Online
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Lelang Online
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +98,Please specify either Quantity or Valuation Rate or both,Silakan tentukan baik Quantity atau Tingkat Penilaian atau keduanya
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,Pemenuhan
 apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Lihat Troli
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Beban Pemasaran
 ,Item Shortage Report,Laporan Kekurangan Barang / Item
-apps/erpnext/erpnext/stock/doctype/item/item.js +279,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Berat disebutkan, \n Sebutkan ""Berat UOM"" terlalu"
+apps/erpnext/erpnext/stock/doctype/item/item.js +275,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Berat disebutkan, \n Sebutkan ""Berat UOM"" terlalu"
 DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Permintaan Material yang digunakan untuk membuat Entri Persediaan ini
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Berikutnya Penyusutan Tanggal wajib untuk aset baru
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Berikutnya Penyusutan Tanggal wajib untuk aset baru
 DocType: Student Group Creation Tool,Separate course based Group for every Batch,Kelompok terpisah berdasarkan Kelompok untuk setiap Batch
 apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Unit tunggal Item.
 DocType: Fee Category,Fee Category,biaya Kategori
+DocType: Agriculture Task,Next Business Day,Hari bisnis selanjutnya
+DocType: Customer,Primary Contact Detail,Detail Kontak Utama
 DocType: Drug Prescription,Dosage by time interval,Dosis berdasarkan interval waktu
 ,Student Fee Collection,Mahasiswa Koleksi Fee
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Durasi Penunjukan (menit)
 DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Membuat Entri Akuntansi Untuk Setiap Perpindahan Persediaan
 DocType: Leave Allocation,Total Leaves Allocated,Jumlah cuti Dialokasikan
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +160,Warehouse required at Row No {0},Gudang diperlukan pada Row nomor {0}
-apps/erpnext/erpnext/public/js/setup_wizard.js +139,Please enter valid Financial Year Start and End Dates,Entrikan Tahun Mulai berlaku Keuangan dan Tanggal Akhir
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Gudang diperlukan pada Row nomor {0}
+apps/erpnext/erpnext/public/js/setup_wizard.js +142,Please enter valid Financial Year Start and End Dates,Entrikan Tahun Mulai berlaku Keuangan dan Tanggal Akhir
 DocType: Employee,Date Of Retirement,Tanggal Pensiun
 DocType: Upload Attendance,Get Template,Dapatkan Template
 DocType: Material Request,Transferred,Ditransfer
 DocType: Vehicle,Doors,pintu
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +196,ERPNext Setup Complete!,ERPNext Pengaturan Selesai!
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,ERPNext Pengaturan Selesai!
 DocType: Healthcare Settings,Collect Fee for Patient Registration,Kumpulkan Biaya untuk Registrasi Pasien
+apps/erpnext/erpnext/stock/doctype/item/item.py +650,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Tidak dapat mengubah Atribut setelah transaksi saham. Buat Item baru dan transfer saham ke Item baru
 DocType: Course Assessment Criteria,Weightage,Weightage
 DocType: Purchase Invoice,Tax Breakup,Perpisahan pajak
 DocType: Packing Slip,PS-,PS
+DocType: Member,Non Profit Member,Anggota nirlaba
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Pusat Biaya diperlukan untuk akun 'Rugi Laba' {2}. Silakan membuat Pusat Biaya default untuk Perusahaan.
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +118,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Sudah ada Kelompok Pelanggan dengan nama yang sama, silakan ganti Nama Pelanggan atau ubah nama Kelompok Pelanggan"
+DocType: Payment Schedule,Payment Term,Jangka waktu pembayaran
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +146,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Sudah ada Kelompok Pelanggan dengan nama yang sama, silakan ganti Nama Pelanggan atau ubah nama Kelompok Pelanggan"
+DocType: Land Unit,Area,Daerah
 apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Kontak baru
 DocType: Territory,Parent Territory,Wilayah Induk
 DocType: Sales Invoice,Place of Supply,Tempat Pasokan
@@ -1922,39 +2066,40 @@
 DocType: Announcement,Instructor,Pengajar
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Pilih Item (opsional)
 DocType: Fee Schedule Student Group,Fee Schedule Student Group,Jadwal Biaya Kelompok Pelajar
-DocType: Employee,AB+,AB +
+DocType: Student,AB+,AB +
 DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Jika item ini memiliki varian, maka tidak dapat dipilih dalam order penjualan dll"
 DocType: Lead,Next Contact By,Kontak Selanjutnya Oleh
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +311,Quantity required for Item {0} in row {1},Kuantitas yang dibutuhkan untuk Item {0} di baris {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +314,Quantity required for Item {0} in row {1},Kuantitas yang dibutuhkan untuk Item {0} di baris {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},Gudang {0} tidak dapat dihapus karena ada kuantitas untuk Item {1}
 DocType: Quotation,Order Type,Tipe Order
 ,Item-wise Sales Register,Item-wise Daftar Penjualan
 DocType: Asset,Gross Purchase Amount,Jumlah Pembelian Gross
 apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Saldo awal
 DocType: Asset,Depreciation Method,Metode penyusutan
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +67,Offline,Offline
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +64,Offline,Offline
 DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Apakah Pajak ini termasuk dalam Basic Rate?
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Total Jumlah Target
+DocType: Soil Texture,Sand Composition (%),Komposisi Pasir (%)
 DocType: Job Applicant,Applicant for a Job,Pemohon untuk Lowongan Kerja
 DocType: Production Plan Material Request,Production Plan Material Request,Produksi Permintaan Rencana Material
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Tidak ada Order Produksi dibuat
 DocType: Stock Reconciliation,Reconciliation JSON,Rekonsiliasi JSON
 apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Terlalu banyak kolom. Mengekspor laporan dan mencetaknya menggunakan aplikasi spreadsheet.
 DocType: Purchase Invoice Item,Batch No,No. Batch
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +141,Request for Quotation: {0},Permintaan Kutipan: {0}
 DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Memungkinkan beberapa Order Penjualan terhadap Order Pembelian dari Pelanggan
 DocType: Student Group Instructor,Student Group Instructor,Instruktur Kelompok Mahasiswa
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Ponsel Tidak
-apps/erpnext/erpnext/setup/doctype/company/company.py +197,Main,Utama
-apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant,Varian
+DocType: Grant Application,Assessment  Mark (Out of 10),Tanda Penilaian (Dari 10)
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Ponsel Tidak
+apps/erpnext/erpnext/setup/doctype/company/company.py +194,Main,Utama
+apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Varian
 DocType: Naming Series,Set prefix for numbering series on your transactions,Mengatur awalan untuk penomoran seri pada transaksi Anda
 DocType: Employee Attendance Tool,Employees HTML,Karyawan HTML
-apps/erpnext/erpnext/stock/doctype/item/item.py +428,Default BOM ({0}) must be active for this item or its template,Standar BOM ({0}) harus aktif untuk item ini atau template-nya
+apps/erpnext/erpnext/stock/doctype/item/item.py +444,Default BOM ({0}) must be active for this item or its template,Standar BOM ({0}) harus aktif untuk item ini atau template-nya
 DocType: Employee,Leave Encashed?,Cuti dicairkan?
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Peluang Dari Bidang Usaha Wajib Diisi
 DocType: Email Digest,Annual Expenses,Beban tahunan
 DocType: Item,Variants,Varian
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1088,Make Purchase Order,Buat Order Pembelian
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1137,Make Purchase Order,Buat Order Pembelian
 DocType: SMS Center,Send To,Kirim Ke
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},Tidak ada saldo cuti cukup bagi Leave Type {0}
 DocType: Payment Reconciliation Payment,Allocated amount,Jumlah yang dialokasikan
@@ -1962,36 +2107,38 @@
 DocType: Sales Invoice Item,Customer's Item Code,Kode Barang Pelanggan
 DocType: Stock Reconciliation,Stock Reconciliation,Rekonsiliasi Persediaan
 DocType: Territory,Territory Name,Nama Wilayah
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +177,Work-in-Progress Warehouse is required before Submit,Kerja-in-Progress Gudang diperlukan sebelum Submit
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,Kerja-in-Progress Gudang diperlukan sebelum Submit
 apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Pemohon untuk Lowongan Pekerjaan
 DocType: Purchase Order Item,Warehouse and Reference,Gudang dan Referensi
 DocType: Supplier,Statutory info and other general information about your Supplier,Info Statutory dan informasi umum lainnya tentang Supplier Anda
 DocType: Item,Serial Nos and Batches,Nomor Seri dan Partai
-apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Kekuatan Kelompok Mahasiswa
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Kekuatan Kelompok Mahasiswa
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +250,Against Journal Entry {0} does not have any unmatched {1} entry,Catatan Jurnal {0} tidak memiliki {1} catatan yang belum dicocokan.
-apps/erpnext/erpnext/config/hr.py +137,Appraisals,Penilaian
+apps/erpnext/erpnext/config/hr.py +142,Appraisals,Penilaian
 apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Acara Pelatihan
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Gandakan Serial ada dimasukkan untuk Item {0}
 DocType: Shipping Rule Condition,A condition for a Shipping Rule,Sebuah kondisi untuk Aturan Pengiriman
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +161,Please enter ,masukkan
-apps/erpnext/erpnext/controllers/accounts_controller.py +423,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Tidak bisa overbill untuk Item {0} berturut-turut {1} lebih dari {2}. Untuk memungkinkan over-billing, silakan diatur dalam Membeli Pengaturan"
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +212,Please set filter based on Item or Warehouse,Silahkan mengatur filter berdasarkan Barang atau Gudang
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,masukkan
+apps/erpnext/erpnext/controllers/accounts_controller.py +467,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Tidak bisa overbill untuk Item {0} berturut-turut {1} lebih dari {2}. Untuk memungkinkan over-billing, silakan diatur dalam Membeli Pengaturan"
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Log Pemeliharaan
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +234,Please set filter based on Item or Warehouse,Silahkan mengatur filter berdasarkan Barang atau Gudang
 DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Berat bersih package ini. (Dihitung secara otomatis sebagai jumlah berat bersih item)
 DocType: Sales Order,To Deliver and Bill,Untuk Dikirim dan Ditagih
 DocType: Student Group,Instructors,instruktur
 DocType: GL Entry,Credit Amount in Account Currency,Jumlah kredit di Akun Mata Uang
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +584,BOM {0} must be submitted,BOM {0} harus terposting
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +588,BOM {0} must be submitted,BOM {0} harus terposting
 DocType: Authorization Control,Authorization Control,Pengendali Otorisasi
-apps/erpnext/erpnext/controllers/buying_controller.py +308,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Ditolak Gudang adalah wajib terhadap ditolak Stok Barang {1}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Payment,Pembayaran
+apps/erpnext/erpnext/controllers/buying_controller.py +309,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Ditolak Gudang adalah wajib terhadap ditolak Stok Barang {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Payment,Pembayaran
 apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Gudang {0} tidak ditautkan ke akun apa pun, sebutkan akun di catatan gudang atau tetapkan akun persediaan baku di perusahaan {1}."
 apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Mengelola pesanan Anda
 DocType: Production Order Operation,Actual Time and Cost,Waktu dan Biaya Aktual
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +54,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Permintaan Bahan maksimal {0} dapat dibuat untuk Item {1} terhadap Sales Order {2}
+DocType: Crop,Crop Spacing,Jarak tanam
 DocType: Course,Course Abbreviation,Singkatan saja
 DocType: Student Leave Application,Student Leave Application,Mahasiswa Cuti Aplikasi
 DocType: Item,Will also apply for variants,Juga akan berlaku untuk varian
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Aset tidak dapat dibatalkan, karena sudah {0}"
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Aset tidak dapat dibatalkan, karena sudah {0}"
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Karyawan {0} tentang Half hari {1}
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Jumlah jam kerja tidak boleh lebih besar dari max jam kerja {0}
 apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Nyala
@@ -2001,9 +2148,9 @@
 DocType: Quality Inspection Reading,Reading 10,Membaca 10
 DocType: Hub Category,Hub Node,Hub Node
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Anda telah memasukan item duplikat. Harap perbaiki dan coba lagi.
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +125,Associate,Rekan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Rekan
 DocType: Asset Movement,Asset Movement,Gerakan aset
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2165,New Cart,Cart baru
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2180,New Cart,Cart baru
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Item {0} bukan merupakan Stok Barang serial
 DocType: SMS Center,Create Receiver List,Buat Daftar Penerima
 DocType: Vehicle,Wheels,roda
@@ -2014,18 +2161,21 @@
 DocType: Activity Cost,Activity Cost,Biaya Aktivitas
 DocType: Sales Invoice Timesheet,Timesheet Detail,Detil absen
 DocType: Purchase Receipt Item Supplied,Consumed Qty,Qty Dikonsumsi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +52,Telecommunications,Telekomunikasi
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekomunikasi
+apps/erpnext/erpnext/accounts/party.py +266,Billing currency must be equal to either default company's currency or party account currency,Mata uang penagihan harus sama dengan mata uang perusahaan atau valuta mata uang perusahaan default
 DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Menunjukkan bahwa paket tersebut merupakan bagian dari pengiriman ini (Hanya Draft)
+DocType: Soil Texture,Loam,Lempung
+apps/erpnext/erpnext/controllers/accounts_controller.py +680,Row {0}: Due Date cannot be before posting date,Baris {0}: Tanggal Jatuh Tempo tidak boleh sebelum tanggal posting
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Buat Entri Pembayaran
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Kuantitas untuk Item {0} harus kurang dari {1}
 ,Sales Invoice Trends,Trend Faktur Penjualan
 DocType: Leave Application,Apply / Approve Leaves,Mohon / Approve Cuti
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Untuk
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +150,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Dapat merujuk baris hanya jika jenis biaya adalah 'On Sebelumnya Row Jumlah' atau 'Sebelumnya Row Jumlah'
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Dapat merujuk baris hanya jika jenis biaya adalah 'On Sebelumnya Row Jumlah' atau 'Sebelumnya Row Jumlah'
 DocType: Sales Order Item,Delivery Warehouse,Gudang Pengiriman
-apps/erpnext/erpnext/config/accounts.py +249,Tree of financial Cost Centers.,Pohon Pusat Biaya keuangan.
+apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Pohon Pusat Biaya keuangan.
 DocType: Serial No,Delivery Document No,Nomor Dokumen Pengiriman
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Silahkan mengatur &#39;Gain / Loss Account pada Asset Disposal&#39; di Perusahaan {0}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Silahkan mengatur &#39;Gain / Loss Account pada Asset Disposal&#39; di Perusahaan {0}
 DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Dapatkan Produk Dari Pembelian Penerimaan
 DocType: Serial No,Creation Date,Tanggal Pembuatan
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Item {0} muncul beberapa kali dalam Daftar Harga {1}
@@ -2038,19 +2188,20 @@
 apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Perbarui tanggapan
 apps/erpnext/erpnext/public/js/utils.js +226,You have already selected items from {0} {1},Anda sudah memilih item dari {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Nama Distribusi Bulanan
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +25,Batch ID is mandatory,Batch ID adalah wajib
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +26,Batch ID is mandatory,Batch ID adalah wajib
 DocType: Sales Person,Parent Sales Person,Induk Sales Person
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +180,High to Low,Tinggi ke Rendah
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +24,Select the program first,Pilih programnya dulu
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Pilih programnya dulu
 DocType: Patient Appointment,Patient Age,Usia pasien
 apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Pengelolaan Proyek
 DocType: Supplier,Supplier of Goods or Services.,Supplier Stok Barang atau Jasa.
 DocType: Budget,Fiscal Year,Tahun Fiskal
+DocType: Asset Maintenance Log,Planned,Berencana
 DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,Rekening piutang bawaan yang akan digunakan jika tidak diatur oleh Pasien untuk memesan biaya Konsultasi.
 DocType: Vehicle Log,Fuel Price,Harga BBM
 DocType: Budget,Budget,Anggaran belanja
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +43,Set Open,Setel Buka
-apps/erpnext/erpnext/stock/doctype/item/item.py +245,Fixed Asset Item must be a non-stock item.,Fixed Asset Item harus barang non-persediaan.
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Setel Buka
+apps/erpnext/erpnext/stock/doctype/item/item.py +247,Fixed Asset Item must be a non-stock item.,Fixed Asset Item harus barang non-persediaan.
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Anggaran tidak dapat ditugaskan terhadap {0}, karena itu bukan Penghasilan atau Beban akun"
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Tercapai
 DocType: Student Admission,Application Form Route,Form aplikasi Route
@@ -2064,12 +2215,13 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,Stok Barang {0} tidak setup untuk Nomor Seri. Periksa Induk Barang
 DocType: Maintenance Visit,Maintenance Time,Waktu Pemeliharaan
 ,Amount to Deliver,Jumlah untuk Dikirim
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +321,Same item has been entered multiple times. {0},Item yang sama telah beberapa kali dimasukkan. {0}
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Jangka Tanggal Mulai tidak dapat lebih awal dari Tahun Tanggal Mulai Tahun Akademik yang istilah terkait (Tahun Akademik {}). Perbaiki tanggal dan coba lagi.
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Same item has been entered multiple times. {0},Item yang sama telah beberapa kali dimasukkan. {0}
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Jangka Tanggal Mulai tidak dapat lebih awal dari Tahun Tanggal Mulai Tahun Akademik yang istilah terkait (Tahun Akademik {}). Perbaiki tanggal dan coba lagi.
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +192,There were errors.,Ada kesalahan.
 DocType: Guardian,Guardian Interests,wali Minat
 DocType: Naming Series,Current Value,Nilai saat ini
-apps/erpnext/erpnext/controllers/accounts_controller.py +240,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Beberapa tahun fiskal ada untuk tanggal {0}. Silakan set perusahaan di Tahun Anggaran
-DocType: School Settings,Instructor Records to be created by,Catatan Instruktur yang akan dibuat oleh
+apps/erpnext/erpnext/controllers/accounts_controller.py +263,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Beberapa tahun fiskal ada untuk tanggal {0}. Silakan set perusahaan di Tahun Anggaran
+DocType: Education Settings,Instructor Records to be created by,Catatan Instruktur yang akan dibuat oleh
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} dibuat
 DocType: Delivery Note Item,Against Sales Order,Berdasarkan Order Penjualan
 ,Serial No Status,Status Nomor Serial
@@ -2081,19 +2233,20 @@
  harus lebih besar dari atau sama dengan {2}"
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Hal ini didasarkan pada pergerakan persediaan. Lihat {0} untuk rincian
 DocType: Pricing Rule,Selling,Penjualan
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +378,Amount {0} {1} deducted against {2},Jumlah {0} {1} dipotong terhadap {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Amount {0} {1} deducted against {2},Jumlah {0} {1} dipotong terhadap {2}
 DocType: Employee,Salary Information,Informasi Gaji
 DocType: Sales Person,Name and Employee ID,Nama dan ID Karyawan
-apps/erpnext/erpnext/accounts/party.py +310,Due Date cannot be before Posting Date,Tanggal jatuh tempo tidak bisa sebelum Tanggal Posting
+apps/erpnext/erpnext/accounts/party.py +311,Due Date cannot be before Posting Date,Tanggal jatuh tempo tidak bisa sebelum Tanggal Posting
 DocType: Website Item Group,Website Item Group,Situs Stok Barang Grup
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Tarif dan Pajak
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,Harap masukkan tanggal Referensi
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Please enter Reference date,Harap masukkan tanggal Referensi
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} entri pembayaran tidak dapat disaring oleh {1}
 DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tabel untuk Item yang akan ditampilkan di Situs Web
 DocType: Purchase Order Item Supplied,Supplied Qty,Qty Disupply
 DocType: Purchase Order Item,Material Request Item,Item Permintaan Material
 apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Tree Item Grup.
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +160,Cannot refer row number greater than or equal to current row number for this Charge type,Tidak dapat merujuk nomor baris yang lebih besar dari atau sama dengan nomor baris saat ini untuk jenis Biaya ini
+DocType: Payroll Entry,Get Employee Details,Dapatkan Rincian Karyawan
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,Cannot refer row number greater than or equal to current row number for this Charge type,Tidak dapat merujuk nomor baris yang lebih besar dari atau sama dengan nomor baris saat ini untuk jenis Biaya ini
 DocType: Asset,Sold,Terjual
 ,Item-wise Purchase History,Laporan Riwayat Pembelian berdasarkan Stok Barang/Item
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Silahkan klik 'Menghasilkan Jadwal' untuk mengambil Serial yang ditambahkan untuk Item {0}
@@ -2105,7 +2258,7 @@
 DocType: Sales Invoice,Accounting Details,Rincian Akuntansi
 apps/erpnext/erpnext/setup/doctype/company/company.js +84,Delete all the Transactions for this Company,Hapus semua Transaksi untuk Perusahaan ini
 DocType: Patient,O Positive,O Positif
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +190,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operasi {1} tidak selesai untuk {2} qty Stok Barang jadi di Produksi Orde # {3}. Silakan update status operasi via Waktu Log
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +195,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operasi {1} tidak selesai untuk {2} qty Stok Barang jadi di Produksi Orde # {3}. Silakan update status operasi via Waktu Log
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investasi
 DocType: Issue,Resolution Details,Detail Resolusi
 apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,Alokasi
@@ -2117,6 +2270,7 @@
 DocType: Employee Loan Application,Total Payable Amount,Jumlah Total Hutang
 DocType: Task,Expected Time (in hours),Waktu yang diharapkan (dalam jam)
 DocType: Item Reorder,Check in (group),Check in (kelompok)
+DocType: Soil Texture,Silt,Lanau
 ,Qty to Order,Kuantitas untuk diorder
 DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Account kepala di bawah Kewajiban atau Ekuitas, di mana Laba / Rugi akan dipesan"
 apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Gantt chart dari semua tugas.
@@ -2126,7 +2280,7 @@
 DocType: Course,Default Grading Scale,Skala Grading bawaan
 DocType: Appraisal,For Employee Name,Untuk Nama Karyawan
 DocType: Holiday List,Clear Table,Bersihkan Table
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Available slots,Slot yang tersedia
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Slot yang tersedia
 DocType: C-Form Invoice Detail,Invoice No,Nomor Faktur
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Melakukan pembayaran
 DocType: Room,Room Name,Nama ruangan
@@ -2137,15 +2291,18 @@
 ,Campaign Efficiency,Efisiensi Promosi
 DocType: Discussion,Discussion,Diskusi
 DocType: Payment Entry,Transaction ID,ID transaksi
+DocType: Volunteer,Anytime,Kapan saja
 DocType: Patient,Surgical History,Sejarah Bedah
 DocType: Employee,Resignation Letter Date,Tanggal Surat Pengunduran Diri
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Aturan harga selanjutnya disaring berdasarkan kuantitas.
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Harap atur tanggal bergabung untuk karyawan {0}
 DocType: Task,Total Billing Amount (via Time Sheet),Jumlah Total Penagihan (via Waktu Lembar)
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Pendapatan Pelanggan Rutin
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +175,{0} ({1}) must have role 'Expense Approver',{0} ({1}) harus memiliki akses sebagai 'Pemberi Izin Pengeluaran'
-apps/erpnext/erpnext/utilities/user_progress.py +125,Pair,Pasangan
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +912,Select BOM and Qty for Production,Pilih BOM dan Qty untuk Produksi
+DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
+DocType: Chapter,Chapter,Bab
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +200,{0} ({1}) must have role 'Expense Approver',{0} ({1}) harus memiliki akses sebagai 'Pemberi Izin Pengeluaran'
+apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Pasangan
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +959,Select BOM and Qty for Production,Pilih BOM dan Qty untuk Produksi
 DocType: Asset,Depreciation Schedule,Jadwal penyusutan
 apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Alamat Mitra Penjualan Dan Kontak
 DocType: Bank Reconciliation Detail,Against Account,Terhadap Akun
@@ -2153,37 +2310,41 @@
 DocType: Maintenance Schedule Detail,Actual Date,Tanggal Aktual
 DocType: Item,Has Batch No,Bernomor Batch
 apps/erpnext/erpnext/public/js/utils.js +100,Annual Billing: {0},Penagihan tahunan: {0}
-apps/erpnext/erpnext/config/accounts.py +208,Goods and Services Tax (GST India),Pajak Barang dan Jasa (GST India)
+apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Pajak Barang dan Jasa (GST India)
 DocType: Delivery Note,Excise Page Number,Jumlah Halaman Excise
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +157,"Company, From Date and To Date is mandatory","Perusahaan, Dari Tanggal dan To Date adalah wajib"
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +225,"Company, From Date and To Date is mandatory","Perusahaan, Dari Tanggal dan To Date adalah wajib"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Dapatkan Konsultasi
 DocType: Asset,Purchase Date,Tanggal Pembelian
-DocType: Employee,Personal Details,Data Pribadi
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Silahkan mengatur &#39;Biaya Penyusutan Asset Center di Perusahaan {0}
+DocType: Volunteer,Volunteer Type,Jenis Relawan
+DocType: Student,Personal Details,Data Pribadi
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Silahkan mengatur &#39;Biaya Penyusutan Asset Center di Perusahaan {0}
 ,Maintenance Schedules,Jadwal pemeliharaan
 DocType: Task,Actual End Date (via Time Sheet),Tanggal Akhir Aktual (dari Lembar Waktu)
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +373,Amount {0} {1} against {2} {3},Jumlah {0} {1} terhadap {2} {3}
+DocType: Soil Texture,Soil Type,Jenis tanah
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Amount {0} {1} against {2} {3},Jumlah {0} {1} terhadap {2} {3}
 ,Quotation Trends,Trend Penawaran
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +159,Item Group not mentioned in item master for item {0},Item Grup tidak disebutkan dalam master Stok Barang untuk item {0}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +358,Debit To account must be a Receivable account,Debit Untuk akun harus rekening Piutang
-DocType: Shipping Rule Condition,Shipping Amount,Jumlah Pengiriman
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To account must be a Receivable account,Debit Untuk akun harus rekening Piutang
+DocType: Shipping Rule,Shipping Amount,Jumlah Pengiriman
 DocType: Supplier Scorecard Period,Period Score,Skor Periode
 apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Tambahkan Pelanggan
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Jumlah Pending
 DocType: Lab Test Template,Special,Khusus
-DocType: Purchase Invoice Item,Conversion Factor,Faktor konversi
+DocType: Purchase Order Item Supplied,Conversion Factor,Faktor konversi
 DocType: Purchase Order,Delivered,Dikirim
 ,Vehicle Expenses,Beban kendaraan
 DocType: Serial No,Invoice Details,Detail faktur
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},nilai yang diharapkan setelah masa manfaat harus lebih besar dari atau sama dengan {0}
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +29,Start on,Mulai dari
+DocType: Grant Application,Show on Website,Tampilkan di Website
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},nilai yang diharapkan setelah masa manfaat harus lebih besar dari atau sama dengan {0}
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Mulai dari
 DocType: Hub Category,Hub Category,Kategori Hub
 DocType: Purchase Invoice,SEZ,SEZ
 DocType: Purchase Receipt,Vehicle Number,Nomor Kendaraan
 DocType: Employee Loan,Loan Amount,Jumlah pinjaman
+apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Tambahkan kop surat
 DocType: Program Enrollment,Self-Driving Vehicle,Kendaraan Mengemudi Sendiri
 DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Supplier Scorecard Berdiri
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +419,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Bill of Material tidak ditemukan Item {1}
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +420,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Bill of Material tidak ditemukan Item {1}
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Jumlah cuti dialokasikan {0} tidak bisa kurang dari cuti yang telah disetujui {1} untuk periode
 DocType: Journal Entry,Accounts Receivable,Piutang
 ,Supplier-Wise Sales Analytics,Sales Analitikal berdasarkan Supplier
@@ -2194,28 +2355,29 @@
 DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Kursus Orang Tua (Biarkan kosong, jika ini bukan bagian dari Kursus Orang Tua)"
 DocType: Leave Control Panel,Leave blank if considered for all employee types,Biarkan kosong jika dipertimbangkan untuk semua jenis karyawan
 DocType: Landed Cost Voucher,Distribute Charges Based On,Distribusi Biaya Berdasarkan
-apps/erpnext/erpnext/hooks.py +140,Timesheets,timesheets
+apps/erpnext/erpnext/hooks.py +144,Timesheets,timesheets
 DocType: HR Settings,HR Settings,Pengaturan Sumber Daya Manusia
 DocType: Salary Slip,net pay info,net Info pay
 DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Nilai ini diperbarui dalam Daftar Harga Penjualan Default.
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +111,Expense Claim is pending approval. Only the Expense Approver can update status.,Beban Klaim sedang menunggu persetujuan. Hanya Approver Beban dapat memperbarui status.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +122,Expense Claim is pending approval. Only the Expense Approver can update status.,Beban Klaim sedang menunggu persetujuan. Hanya Approver Beban dapat memperbarui status.
 DocType: Email Digest,New Expenses,Beban baru
 DocType: Purchase Invoice,Additional Discount Amount,Jumlah Potongan Tambahan
 DocType: Consultation,Patient Details,Rincian pasien
 DocType: Patient,B Positive,B Positif
-apps/erpnext/erpnext/controllers/accounts_controller.py +531,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Qty harus 1, sebagai item aset tetap. Silakan gunakan baris terpisah untuk beberapa qty."
+apps/erpnext/erpnext/controllers/accounts_controller.py +575,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Qty harus 1, sebagai item aset tetap. Silakan gunakan baris terpisah untuk beberapa qty."
 DocType: Leave Block List Allow,Leave Block List Allow,Cuti Block List Izinkan
-apps/erpnext/erpnext/setup/doctype/company/company.py +291,Abbr can not be blank or space,Singkatan tidak boleh kosong atau spasi
+apps/erpnext/erpnext/setup/doctype/company/company.py +288,Abbr can not be blank or space,Singkatan tidak boleh kosong atau spasi
 DocType: Patient Medical Record,Patient Medical Record,Catatan Medis Pasien
-apps/erpnext/erpnext/accounts/doctype/account/account.js +62,Group to Non-Group,Kelompok Non-kelompok
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,Olahraga
+apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Kelompok Non-kelompok
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Olahraga
 DocType: Loan Type,Loan Name,pinjaman Nama
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Total Aktual
 DocType: Lab Test UOM,Test UOM,Uji UOM
 DocType: Student Siblings,Student Siblings,Saudara mahasiswa
-apps/erpnext/erpnext/utilities/user_progress.py +125,Unit,Satuan
-apps/erpnext/erpnext/stock/get_item_details.py +141,Please specify Company,Silakan tentukan Perusahaan
+apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Satuan
+apps/erpnext/erpnext/stock/get_item_details.py +136,Please specify Company,Silakan tentukan Perusahaan
 ,Customer Acquisition and Loyalty,Akuisisi dan Loyalitas Pelanggan
+DocType: Asset Maintenance Task,Maintenance Task,Tugas pemeliharaan
 DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Gudang di mana Anda menyimpan barang-barang yang ditolak/reject
 DocType: Production Order,Skip Material Transfer,Lewati Transfer Material
 apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Tidak dapat menemukan nilai tukar untuk {0} sampai {1} untuk tanggal kunci {2}. Buat catatan Currency Exchange secara manual
@@ -2225,70 +2387,73 @@
 DocType: Issue,Support,Support
 ,BOM Search,Pencarian BOM
 DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publish &quot;In Stock&quot; atau &quot;Not in Stock&quot; di Hub berdasarkan stok yang ada di gudang ini.
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +189,Closing (Opening + Totals),Penutupan (Membuka Total +)
 DocType: Vehicle,Fuel Type,Jenis bahan bakar
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Silakan tentukan mata uang di Perusahaan
 DocType: Workstation,Wages per hour,Upah per jam
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Saldo Persediaan di Batch {0} akan menjadi negatif {1} untuk Barang {2} di Gudang {3}
 apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Berikut Permintaan Bahan telah dibesarkan secara otomatis berdasarkan tingkat re-order Item
 DocType: Email Digest,Pending Sales Orders,Pending Order Penjualan
-apps/erpnext/erpnext/controllers/accounts_controller.py +279,Account {0} is invalid. Account Currency must be {1},Akun {0} tidak berlaku. Mata Uang Akun harus {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +302,Account {0} is invalid. Account Currency must be {1},Akun {0} tidak berlaku. Mata Uang Akun harus {1}
 DocType: Healthcare Settings,Remind Before,Ingatkan sebelumnya
 apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Faktor UOM Konversi diperlukan berturut-turut {0}
 DocType: Production Plan Item,material_request_item,material_request_item
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1034,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Dokumen Referensi Type harus menjadi salah satu Sales Order, Faktur Penjualan atau Journal Entri"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1060,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Dokumen Referensi Type harus menjadi salah satu Sales Order, Faktur Penjualan atau Journal Entri"
 DocType: Salary Component,Deduction,Deduksi
+DocType: Item,Retain Sample,Simpan sampel
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Row {0}: Dari Waktu dan To Waktu adalah wajib.
 DocType: Stock Reconciliation Item,Amount Difference,jumlah Perbedaan
-apps/erpnext/erpnext/stock/get_item_details.py +306,Item Price added for {0} in Price List {1},Item Harga ditambahkan untuk {0} di Daftar Harga {1}
+apps/erpnext/erpnext/stock/get_item_details.py +349,Item Price added for {0} in Price List {1},Item Harga ditambahkan untuk {0} di Daftar Harga {1}
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Cukup masukkan Id Karyawan Sales Person ini
 DocType: Territory,Classification of Customers by region,Klasifikasi Pelanggan menurut wilayah
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +57,Difference Amount must be zero,Perbedaan Jumlah harus nol
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,Dalam produksi
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +59,Difference Amount must be zero,Perbedaan Jumlah harus nol
 DocType: Project,Gross Margin,Margin kotor
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,Please enter Production Item first,Entrikan Produksi Stok Barang terlebih dahulu
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Dihitung keseimbangan Laporan Bank
 DocType: Normal Test Template,Normal Test Template,Template Uji Normal
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,Pengguna Non-aktif
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +764,Quotation,Penawaran
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +957,Cannot set a received RFQ to No Quote,Tidak dapat mengatur RFQ yang diterima ke No Quote
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +913,Quotation,Penawaran
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +982,Cannot set a received RFQ to No Quote,Tidak dapat mengatur RFQ yang diterima ke No Quote
 DocType: Quotation,QTN-,QTN-
 DocType: Salary Slip,Total Deduction,Jumlah Deduksi
 ,Production Analytics,Analytics produksi
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Hal ini didasarkan pada transaksi melawan Pasien ini. Lihat garis waktu di bawah untuk rinciannya
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +201,Cost Updated,Perbarui Biaya
-DocType: Employee,Date of Birth,Tanggal Lahir
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Item Code&gt; Item Group&gt; Brand
+DocType: Patient,Date of Birth,Tanggal Lahir
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,Item {0} telah dikembalikan
 DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Tahun Anggaran ** mewakili Tahun Keuangan. Semua entri akuntansi dan transaksi besar lainnya dilacak terhadap Tahun Anggaran ** **.
 DocType: Opportunity,Customer / Lead Address,Alamat Pelanggan / Prospek
-DocType: Patient,DOB,DOB
 DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Penyiapan Scorecard Pemasok
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Nama Rencana Penilaian
-apps/erpnext/erpnext/stock/doctype/item/item.py +220,Warning: Invalid SSL certificate on attachment {0},Peringatan: Sertifikat SSL tidak valid pada lampiran {0}
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Nama Rencana Penilaian
+apps/erpnext/erpnext/stock/doctype/item/item.py +222,Warning: Invalid SSL certificate on attachment {0},Peringatan: Sertifikat SSL tidak valid pada lampiran {0}
 apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Prospek membantu Anda mendapatkan bisnis, tambahkan semua kontak Anda sebagai prospek Anda"
 DocType: Production Order Operation,Actual Operation Time,Waktu Operasi Aktual
 DocType: Authorization Rule,Applicable To (User),Berlaku Untuk (User)
 DocType: Purchase Taxes and Charges,Deduct,Pengurangan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +226,Job Description,Deskripsi Bidang Kerja
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Job Description,Deskripsi Bidang Kerja
 DocType: Student Applicant,Applied,Terapan
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +834,Re-open,Re-terbuka
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +859,Re-open,Re-terbuka
 DocType: Sales Invoice Item,Qty as per Stock UOM,Kuantitas sesuai UOM Persediaan
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Nama Guardian2
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Nama Guardian2
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Karakter khusus kecuali ""-"" ""."", ""#"", dan ""/"" tidak diperbolehkan dalam penamaan seri"
 DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Pantau Kampanye Penjualan. Pantau Prospek, Penawaran, Perintah Penjualan dll dari Kampanye untuk mengukur Return on Investment."
 DocType: Expense Claim,Approver,Approver
 ,SO Qty,SO Qty
 DocType: Guardian,Work Address,kerja Alamat
 DocType: Appraisal,Calculate Total Score,Hitung Total Skor
-DocType: Request for Quotation,Manufacturing Manager,Manajer Manufaktur
+DocType: Asset Repair,Manufacturing Manager,Manajer Manufaktur
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serial ada {0} masih dalam garansi upto {1}
-apps/erpnext/erpnext/config/stock.py +163,Split Delivery Note into packages.,Membagi Pengiriman Catatan ke dalam paket.
-apps/erpnext/erpnext/hooks.py +107,Shipments,Pengiriman
+DocType: Plant Analysis Criteria,Minimum Permissible Value,Nilai Diijinkan Minimal
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +42,User {0} already exists,Pengguna {0} sudah ada
+apps/erpnext/erpnext/hooks.py +109,Shipments,Pengiriman
 DocType: Payment Entry,Total Allocated Amount (Company Currency),Total Dialokasikan Jumlah (Perusahaan Mata Uang)
 DocType: Purchase Order Item,To be delivered to customer,Akan dikirimkan ke pelanggan
 DocType: BOM,Scrap Material Cost,Scrap Material Biaya
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,Serial ada {0} bukan milik Gudang setiap
+DocType: Grant Application,Email Notification Sent,Notifikasi Email Terkirim
 DocType: Purchase Invoice,In Words (Company Currency),Dalam Kata-kata (Perusahaan Mata Uang)
-DocType: Asset,Supplier,Supplier
+DocType: Pricing Rule,Supplier,Supplier
 DocType: Consultation,Consultation Time,Waktu Konsultasi
 DocType: C-Form,Quarter,Seperempat
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Beban lain-lain
@@ -2301,112 +2466,120 @@
 DocType: Leave Application,Total Leave Days,Jumlah Cuti Hari
 DocType: Email Digest,Note: Email will not be sent to disabled users,Catatan: Surel tidak akan dikirim ke pengguna non-aktif
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Jumlah Interaksi
-apps/erpnext/erpnext/stock/doctype/item/item.js +102,Item Variant Settings,Pengaturan Variasi Item
+apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Pengaturan Variasi Item
 apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Pilih Perusahaan ...
 DocType: Leave Control Panel,Leave blank if considered for all departments,Biarkan kosong jika dianggap untuk semua departemen
-apps/erpnext/erpnext/config/hr.py +223,"Types of employment (permanent, contract, intern etc.).","Jenis pekerjaan (permanen, kontrak, magang dll)."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +424,{0} is mandatory for Item {1},{0} adalah wajib untuk Item {1}
-DocType: Process Payroll,Fortnightly,sekali dua minggu
+apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Jenis pekerjaan (permanen, kontrak, magang dll)."
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +428,{0} is mandatory for Item {1},{0} adalah wajib untuk Item {1}
+DocType: Payroll Entry,Fortnightly,sekali dua minggu
 DocType: Currency Exchange,From Currency,Dari mata uang
 DocType: Vital Signs,Weight (In Kilogram),Berat (dalam Kilogram)
+DocType: Chapter,"chapters/chapter_name
+leave blank automatically set after saving chapter.",bab / chapter_name kosongkan secara otomatis setelah bab save.
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Silakan pilih Jumlah Alokasi, Faktur Jenis dan Faktur Nomor di minimal satu baris"
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +125,Cost of New Purchase,Biaya Pembelian New
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Biaya Pembelian New
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Sales Order yang diperlukan untuk Item {0}
+DocType: Grant Application,Grant Description,Deskripsi Hibah
 DocType: Purchase Invoice Item,Rate (Company Currency),Rate (Perusahaan Mata Uang)
 DocType: Student Guardian,Others,Lainnya
 DocType: Payment Entry,Unallocated Amount,Jumlah yang tidak terisi
 apps/erpnext/erpnext/templates/includes/product_page.js +71,Cannot find a matching Item. Please select some other value for {0}.,Tidak dapat menemukan yang cocok Item. Silakan pilih beberapa nilai lain untuk {0}.
 DocType: POS Profile,Taxes and Charges,Pajak dan Biaya
 DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produk atau Jasa yang dibeli, dijual atau disimpan dalam persediaan."
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Silakan setup Employee Naming System di Human Resource&gt; HR Settings
 apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Tidak ada update lebih
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +154,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Tidak dapat memilih jenis biaya sebagai 'Pada Row Sebelumnya Jumlah' atau 'On Sebelumnya Row Jumlah' untuk baris terlebih dahulu
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Tidak dapat memilih jenis biaya sebagai 'Pada Row Sebelumnya Jumlah' atau 'On Sebelumnya Row Jumlah' untuk baris terlebih dahulu
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Ini mencakup semua scorecard yang terkait dengan Setup ini
 apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Barang Turunan tidak boleh berupa sebuah Bundel Produk. Silahkan hapus barang `{0}` dan simpan
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Perbankan
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Perbankan
 apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,menambahkan Timesheets
 DocType: Vehicle Service,Service Item,layanan Barang
 DocType: Bank Guarantee,Bank Guarantee,Bank Garansi
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Silahkan klik 'Menghasilkan Jadwal' untuk mendapatkan jadwal
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +56,There were errors while deleting following schedules:,Ada kesalahan saat menghapus jadwal berikut:
 DocType: Bin,Ordered Quantity,Qty Terpesan/Terorder
-apps/erpnext/erpnext/public/js/setup_wizard.js +115,"e.g. ""Build tools for builders""","misalnya ""Membangun alat untuk pembangun """
+apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","misalnya ""Membangun alat untuk pembangun """
 DocType: Grading Scale,Grading Scale Intervals,Grading Scale Interval
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Entri Akuntansi untuk {2} hanya dapat dilakukan dalam bentuk mata uang: {3}
-DocType: Production Order,In Process,Dalam Proses
+DocType: Fee Schedule,In Process,Dalam Proses
 DocType: Authorization Rule,Itemwise Discount,Diskon berdasarkan Item/Stok
 apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Pohon rekening keuangan.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} terhadap Order Penjualan {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +362,{0} against Sales Order {1},{0} terhadap Order Penjualan {1}
 DocType: Account,Fixed Asset,Asset Tetap
 apps/erpnext/erpnext/config/stock.py +320,Serialized Inventory,Persediaan memiliki serial
 DocType: Employee Loan,Account Info,Info akun
 DocType: Activity Type,Default Billing Rate,Standar Tingkat Penagihan
 DocType: Fees,Include Payment,Sertakan Pembayaran
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Kelompok Siswa dibuat.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Kelompok Siswa dibuat.
 DocType: Sales Invoice,Total Billing Amount,Jumlah Total Tagihan
 apps/erpnext/erpnext/hr/doctype/daily_work_summary_settings/daily_work_summary_settings.py +17,There must be a default incoming Email Account enabled for this to work. Please setup a default incoming Email Account (POP/IMAP) and try again.,Harus ada Akun Email masuk default yang aktif supaya hal ini bisa bekerja. Silakan atur Akun Email masuk default (POP / IMAP) dan coba lagi.
-DocType: Healthcare Settings,Receivable Account,Akun Piutang
-apps/erpnext/erpnext/controllers/accounts_controller.py +553,Row #{0}: Asset {1} is already {2},Row # {0}: Aset {1} sudah {2}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Program di Struktur Biaya dan Kelompok Pelajar {0} berbeda.
+DocType: Fee Schedule,Receivable Account,Akun Piutang
+apps/erpnext/erpnext/controllers/accounts_controller.py +597,Row #{0}: Asset {1} is already {2},Row # {0}: Aset {1} sudah {2}
 DocType: Quotation Item,Stock Balance,Saldo Persediaan
 apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Nota Penjualan untuk Pembayaran
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +119,CEO,CEO
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,CEO
 DocType: Purchase Invoice,With Payment of Tax,Dengan pembayaran pajak
 DocType: Expense Claim Detail,Expense Claim Detail,Detail Klaim Biaya
 DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLICATE UNTUK PEMASOK
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +868,Please select correct account,Silakan pilih akun yang benar
-DocType: Item,Weight UOM,Berat UOM
+DocType: Land Unit,Is Container,Adalah kontainer
+DocType: Crop Cycle,This will be day 1 of the crop cycle,Ini akan menjadi hari 1 dari siklus panen
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +869,Please select correct account,Silakan pilih akun yang benar
+DocType: Purchase Invoice Item,Weight UOM,Berat UOM
 DocType: Salary Structure Employee,Salary Structure Employee,Struktur Gaji Karyawan
-DocType: Patient,Blood Group,Golongan darah
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Tampilkan Variant Attributes
+DocType: Student,Blood Group,Golongan darah
 DocType: Course,Course Name,Nama kursus
 DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Pengguna yang dapat menyetujui aplikasi cuti karyawan tertentu yang
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Peralatan Kantor
 DocType: Purchase Invoice Item,Qty,Kuantitas
 DocType: Fiscal Year,Companies,Perusahaan
 DocType: Supplier Scorecard,Scoring Setup,Setup Scoring
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +24,Electronics,Elektronik
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronik
 DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Munculkan Permintaan Material ketika persediaan mencapai tingkat pesan ulang
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +94,Full-time,Full-time
-DocType: Salary Structure,Employees,Para karyawan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Full-time
+DocType: Payroll Entry,Employees,Para karyawan
 DocType: Employee,Contact Details,Kontak Detail
 DocType: C-Form,Received Date,Diterima Tanggal
 DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Jika Anda telah membuat template standar dalam Penjualan Pajak dan Biaya Template, pilih salah satu dan klik pada tombol di bawah ini."
 DocType: BOM Scrap Item,Basic Amount (Company Currency),Nilai Dasar (Mata Uang Perusahaan)
 DocType: Student,Guardians,Penjaga
 DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Harga tidak akan ditampilkan jika Harga Daftar tidak diatur
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +28,Please specify a country for this Shipping Rule or check Worldwide Shipping,Silakan tentukan negara untuk Aturan Pengiriman ini atau periksa Seluruh Dunia Pengiriman
 DocType: Stock Entry,Total Incoming Value,Total nilai masuk
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +352,Debit To is required,Debit Untuk diperlukan
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +356,Debit To is required,Debit Untuk diperlukan
 apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets membantu melacak waktu, biaya dan penagihan untuk kegiatan yang dilakukan oleh tim Anda"
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Pembelian Daftar Harga
 apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Template dari variabel scorecard pemasok.
 DocType: Offer Letter Term,Offer Term,Penawaran Term
-DocType: Quality Inspection,Quality Manager,Manajer Mutu
+DocType: Asset,Quality Manager,Manajer Mutu
 DocType: Job Applicant,Job Opening,Lowongan Pekerjaan
 DocType: Payment Reconciliation,Payment Reconciliation,Rekonsiliasi Pembayaran
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Silahkan Pilih Pihak penanggung jawab
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +51,Technology,Teknologi
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Teknologi
 DocType: Hub Settings,Unregister from Hub,Unregister dari Hub
 apps/erpnext/erpnext/public/js/utils.js +102,Total Unpaid: {0},Total Tunggakan: {0}
 DocType: BOM Website Operation,BOM Website Operation,BOM Operasi Situs
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Surat Penawaran
 apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Menghasilkan Permintaan Material (MRP) dan Order Produksi.
 DocType: Supplier Scorecard,Supplier Score,Skor Pemasok
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +76,Total Invoiced Amt,Jumlah Nilai Tagihan
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +87,Total Invoiced Amt,Jumlah Nilai Tagihan
 DocType: Supplier,Warn RFQs,Peringatkan untuk RFQs
 DocType: BOM,Conversion Rate,Tingkat konversi
 apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Cari produk
-DocType: Physician Schedule Time Slot,To Time,Untuk Waktu
+DocType: Assessment Plan,To Time,Untuk Waktu
 DocType: Authorization Rule,Approving Role (above authorized value),Menyetujui Peran (di atas nilai yang berwenang)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Payable account,Kredit Untuk akun harus rekening Hutang
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Silakan pilih Student Admission yang wajib diisi pemohon uang pelajar
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335,BOM recursion: {0} cannot be parent or child of {2},BOM recursion: {0} tidak bisa menjadi induk atau cabang dari {2}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Kredit Untuk akun harus rekening Hutang
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Silakan pilih Student Admission yang wajib diisi pemohon uang pelajar
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +338,BOM recursion: {0} cannot be parent or child of {2},BOM recursion: {0} tidak bisa menjadi induk atau cabang dari {2}
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +23,Please select a Price List to publish pricing,Silakan pilih Daftar Harga untuk menerbitkan harga
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Daftar anggaran
 DocType: Production Order Operation,Completed Qty,Qty Selesai
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry","Untuk {0}, hanya rekening debit dapat dihubungkan dengan entri kredit lain"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +146,"For {0}, only debit accounts can be linked against another credit entry","Untuk {0}, hanya rekening debit dapat dihubungkan dengan entri kredit lain"
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Daftar Harga {0} dinonaktifkan
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Row {0}: Selesai Qty tidak bisa lebih dari {1} untuk operasi {2}
 DocType: Manufacturing Settings,Allow Overtime,Izinkan Lembur
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serialized Item {0} tidak dapat diperbarui menggunakan Rekonsiliasi Persediaan, gunakan Entri Persediaan"
 DocType: Training Event Employee,Training Event Employee,Acara Pelatihan Karyawan
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +976,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Sampel Maksimum - {0} dapat disimpan untuk Batch {1} dan Item {2}.
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Tambahkan Slot Waktu
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Nomer Seri diperlukan untuk Item {1}. Anda menyediakan {2}.
 DocType: Stock Reconciliation Item,Current Valuation Rate,Nilai Tingkat Penilaian Saat ini
@@ -2423,10 +2596,13 @@
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,Pusat biaya lebih lanjut dapat dibuat di bawah Grup tetapi entri dapat dilakukan terhadap non-Grup
 apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Pengguna dan Perizinan
 DocType: Vehicle Log,VLOG.,VLOG.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +945,Production Orders Created: {0},Produksi Pesanan Dibuat: {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +994,Production Orders Created: {0},Produksi Pesanan Dibuat: {0}
 DocType: Branch,Branch,Cabang
+DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
+DocType: Delivery Trip,Fulfillment User,Pengguna Pemenuhan
 apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Percetakan dan Branding
 DocType: Company,Total Monthly Sales,Total Penjualan Bulanan
+DocType: Agriculture Analysis Criteria,Weather,Cuaca
 DocType: Bin,Actual Quantity,Kuantitas Aktual
 DocType: Shipping Rule,example: Next Day Shipping,Contoh: Hari Berikutnya Pengiriman
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serial No {0} tidak ditemukan
@@ -2435,38 +2611,41 @@
 DocType: Fee Schedule Program,Student Batch,Mahasiswa Batch
 apps/erpnext/erpnext/utilities/activation.py +119,Make Student,membuat Siswa
 DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
-apps/erpnext/erpnext/projects/doctype/project/project.py +203,You have been invited to collaborate on the project: {0},Anda telah diundang untuk berkolaborasi pada proyek: {0}
+apps/erpnext/erpnext/projects/doctype/project/project.py +214,You have been invited to collaborate on the project: {0},Anda telah diundang untuk berkolaborasi pada proyek: {0}
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Physician not available on {0},Dokter tidak tersedia di {0}
 DocType: Leave Block List Date,Block Date,Blok Tanggal
+DocType: Crop,Crop,Tanaman
 DocType: Purchase Receipt,Supplier Delivery Note,Catatan Pengiriman Supplier
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +70,Apply Now,Terapkan Sekarang
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Terapkan Sekarang
 apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Sebenarnya Qty {0} / Menunggu Qty {1}
 DocType: Purchase Invoice,E-commerce GSTIN,E-commerce GSTIN
 DocType: Sales Order,Not Delivered,Tidak Terkirim
-apps/erpnext/erpnext/controllers/buying_controller.py +421,Expected Date cannot be before Transaction Date,Tanggal yang Diharapkan tidak dapat dilakukan sebelum Tanggal Transaksi
+apps/erpnext/erpnext/controllers/buying_controller.py +422,Expected Date cannot be before Transaction Date,Tanggal yang Diharapkan tidak dapat dilakukan sebelum Tanggal Transaksi
 ,Bank Clearance Summary,Ringkasan Kliring Bank
 apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Buat dan kelola surel ringkasan harian, mingguan dan bulanan."
 DocType: Appraisal Goal,Appraisal Goal,Penilaian Pencapaian
 DocType: Stock Reconciliation Item,Current Amount,Jumlah saat ini
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,bangunan
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,Bangunan
 DocType: Fee Schedule,Fee Structure,Struktur biaya
 DocType: Timesheet Detail,Costing Amount,Nilai Jumlah Biaya
 DocType: Student Admission Program,Application Fee,Biaya aplikasi
-DocType: Process Payroll,Submit Salary Slip,Kirim Slip Gaji
-apps/erpnext/erpnext/controllers/selling_controller.py +165,Maxiumm discount for Item {0} is {1}%,Diskon Maxiumm untuk Item {0} adalah {1}%
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,Submit Salary Slip,Kirim Slip Gaji
+apps/erpnext/erpnext/controllers/selling_controller.py +133,Maxiumm discount for Item {0} is {1}%,Diskon Maxiumm untuk Item {0} adalah {1}%
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Impor Secara massal
 DocType: Sales Partner,Address & Contacts,Alamat & Kontak
 DocType: SMS Log,Sender Name,Nama Pengirim
+DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kriteria Analisis Pertanian
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +193,Sort by Criteria,Urutkan menurut Kriteria
-DocType: POS Profile,[Select],[Pilihan]
+DocType: POS Profile,[Select],[Pilih]
 DocType: Vital Signs,Blood Pressure (diastolic),Tekanan Darah (diastolik)
 DocType: SMS Log,Sent To,Dikirim Ke
+DocType: Agriculture Task,Holiday Management,Manajemen liburan
 DocType: Payment Request,Make Sales Invoice,Buat Faktur Penjualan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,software
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +50,Next Contact Date cannot be in the past,Berikutnya Hubungi Tanggal tidak dapat di masa lalu
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,Next Contact Date cannot be in the past,Berikutnya Hubungi Tanggal tidak dapat di masa lalu
 DocType: Company,For Reference Only.,Untuk referensi saja.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +91,Physician {0} not available on {1},Dokter {0} tidak tersedia di {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2519,Select Batch No,Pilih Batch No
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Dokter {0} tidak tersedia di {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2538,Select Batch No,Pilih Batch No
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},Valid {0}: {1}
 DocType: Purchase Invoice,PINV-RET-,PINV-RET-
 DocType: Fee Validity,Reference Inv,Referensi Inv
@@ -2478,12 +2657,12 @@
 DocType: Employee,Employment Details,Rincian Pekerjaan
 DocType: Employee,New Workplace,Tempat Kerja Baru
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Tetapkan untuk ditutup
-apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Barcode {0},Ada Stok Barang dengan Barcode {0}
+apps/erpnext/erpnext/stock/get_item_details.py +125,No Item with Barcode {0},Ada Stok Barang dengan Barcode {0}
 DocType: Normal Test Items,Require Result Value,Mengharuskan Nilai Hasil
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Kasus No tidak bisa 0
 DocType: Item,Show a slideshow at the top of the page,Tampilkan slideshow di bagian atas halaman
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +514,Boms,BOMS
-apps/erpnext/erpnext/stock/doctype/item/item.py +149,Stores,Toko
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +517,Boms,BOMS
+apps/erpnext/erpnext/stock/doctype/item/item.py +151,Stores,Toko
 DocType: Project Type,Projects Manager,Manajer Proyek
 DocType: Serial No,Delivery Time,Waktu Pengiriman
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Umur Berdasarkan
@@ -2498,17 +2677,19 @@
 DocType: Rename Tool,Rename Tool,Alat Perubahan Nama
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Perbarui Biaya
 DocType: Item Reorder,Item Reorder,Item Reorder
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +446,Show Salary Slip,Slip acara Gaji
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +823,Transfer Material,Transfer Material/Stok Barang
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Slip acara Gaji
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +848,Transfer Material,Transfer Material/Stok Barang
 DocType: Fees,Send Payment Request,Kirim Permintaan Pembayaran
 DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Tentukan operasi, biaya operasi dan memberikan Operation unik ada pada operasi Anda."
+DocType: Water Analysis,Origin,Asal
 apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Dokumen ini adalah lebih dari batas oleh {0} {1} untuk item {4}. Apakah Anda membuat yang lain {3} terhadap yang sama {2}?
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1006,Please set recurring after saving,Silahkan mengatur berulang setelah menyimpan
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +758,Select change amount account,Pilih akun berubah jumlah
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1086,Please set recurring after saving,Silahkan mengatur berulang setelah menyimpan
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +763,Select change amount account,Pilih akun berubah jumlah
 DocType: Purchase Invoice,Price List Currency,Daftar Harga Mata uang
 DocType: Naming Series,User must always select,Pengguna harus selalu pilih
 DocType: Stock Settings,Allow Negative Stock,Izinkan persediaan negatif
 DocType: Installation Note,Installation Note,Nota Installasi
+DocType: Soil Texture,Clay,Tanah liat
 DocType: Topic,Topic,Tema
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Arus Kas dari Pendanaan
 DocType: Budget Account,Budget Account,Akun anggaran
@@ -2517,34 +2698,38 @@
 DocType: Grading Scale Interval,Grade Description,kelas Keterangan
 DocType: Stock Entry,Purchase Receipt No,No Nota Penerimaan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Uang Earnest
-DocType: Process Payroll,Create Salary Slip,Buat Slip Gaji
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Lacak
+DocType: Asset Maintenance Log,Actions performed,Tindakan dilakukan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Sumber Dana (Kewajiban)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +381,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Kuantitas di baris {0} ({1}) harus sama dengan jumlah yang diproduksi {2}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +406,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Kuantitas di baris {0} ({1}) harus sama dengan jumlah yang diproduksi {2}
 DocType: Supplier Scorecard Scoring Standing,Employee,Karyawan
+DocType: Asset Repair,Failure Date,Tanggal Kegagalan
 DocType: Sample Collection,Collected Time,Waktu yang Dikumpulkan
 DocType: Company,Sales Monthly History,Riwayat Bulanan Penjualan
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +204,Select Batch,Pilih Batch
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} telah ditagih sepenuhnya
+DocType: Asset Maintenance Task,Next Due Date,Tanggal Jatuh Tempo Berikutnya
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Pilih Batch
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +242,{0} {1} is fully billed,{0} {1} telah ditagih sepenuhnya
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +48,Vital Signs,Tanda-tanda vital
 DocType: Training Event,End Time,Waktu Akhir
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Struktur Gaji aktif {0} ditemukan untuk karyawan {1} untuk tanggal yang diberikan
 DocType: Payment Entry,Payment Deductions or Loss,Pengurangan pembayaran atau Rugi
+DocType: Soil Analysis,Soil Analysis Criterias,Kriteria Analisis Tanah
 apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Ketentuan kontrak standar untuk Penjualan atau Pembelian.
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Group by Voucher
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +186,Are you sure you want to cancel this appointment?,Yakin ingin membatalkan janji temu ini?
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Yakin ingin membatalkan janji temu ini?
 apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,Pipeline penjualan
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +216,Please set default account in Salary Component {0},Silakan set account default di Komponen Gaji {0}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},Silakan set account default di Komponen Gaji {0}
 apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Diperlukan pada
 DocType: Rename Tool,File to Rename,Nama File untuk Diganti
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Silakan pilih BOM untuk Item di Row {0}
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Akun {0} tidak cocok dengan Perusahaan {1} dalam Mode Akun: {2}
-apps/erpnext/erpnext/controllers/buying_controller.py +270,Specified BOM {0} does not exist for Item {1},Ditentukan BOM {0} tidak ada untuk Item {1}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +221,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Jadwal pemeliharaan {0} harus dibatalkan sebelum membatalkan Sales Order ini
+apps/erpnext/erpnext/controllers/buying_controller.py +271,Specified BOM {0} does not exist for Item {1},Ditentukan BOM {0} tidak ada untuk Item {1}
+DocType: Soil Texture,Sandy Loam,Sandy Loam
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Jadwal pemeliharaan {0} harus dibatalkan sebelum membatalkan Sales Order ini
 DocType: POS Profile,Applicable for Users,Berlaku untuk Pengguna
 DocType: Notification Control,Expense Claim Approved,Klaim Biaya Disetujui
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,Salary Slip of employee {0} already created for this period,Slip Gaji karyawan {0} sudah dibuat untuk periode ini
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +151,Pharmaceutical,Farmasi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Farmasi
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Biaya Produk Dibeli
 DocType: Selling Settings,Sales Order Required,Nota Penjualan Diperlukan
 DocType: Purchase Invoice,Credit To,Kredit Untuk
@@ -2554,76 +2739,76 @@
 DocType: Supplier Scorecard,Warn for new Purchase Orders,Peringatkan untuk Pesanan Pembelian baru
 DocType: Quality Inspection Reading,Reading 9,Membaca 9
 DocType: Supplier,Is Frozen,Dibekukan
-apps/erpnext/erpnext/stock/utils.py +217,Group node warehouse is not allowed to select for transactions,gudang kelompok simpul tidak diperbolehkan untuk memilih untuk transaksi
+apps/erpnext/erpnext/stock/utils.py +222,Group node warehouse is not allowed to select for transactions,gudang kelompok simpul tidak diperbolehkan untuk memilih untuk transaksi
 DocType: Buying Settings,Buying Settings,Setting Pembelian
 DocType: Stock Entry Detail,BOM No. for a Finished Good Item,No. BOM untuk Stok Barang Jadi
 DocType: Upload Attendance,Attendance To Date,Kehadiran Sampai Tanggal
 DocType: Request for Quotation Supplier,No Quote,Tidak ada kutipan
 DocType: Warranty Claim,Raised By,Diangkat Oleh
 DocType: Payment Gateway Account,Payment Account,Akun Pembayaran
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +880,Please specify Company to proceed,Silahkan tentukan Perusahaan untuk melanjutkan
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +906,Please specify Company to proceed,Silahkan tentukan Perusahaan untuk melanjutkan
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Perubahan bersih Piutang
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Compensatory Off,Kompensasi Off
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Kompensasi Off
 DocType: Offer Letter,Accepted,Diterima
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,Organisasi
+DocType: Grant Application,Organization,Organisasi
 DocType: BOM Update Tool,BOM Update Tool,Alat Penggantian BOM
-apps/erpnext/erpnext/accounts/party.py +204,"Party account not specified, please setup default party account in company","Rekening pihak tidak ditentukan, silahkan setup akun party default di perusahaan"
 DocType: SG Creation Tool Course,Student Group Name,Nama Kelompok Mahasiswa
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Menciptakan Biaya
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Menciptakan Biaya
 apps/erpnext/erpnext/setup/doctype/company/company.js +62,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,Pastikan Anda benar-benar ingin menghapus semua transaksi untuk perusahaan ini. Data master Anda akan tetap seperti itu. Tindakan ini tidak bisa dibatalkan.
 DocType: Room,Room Number,Nomor kamar
 apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Referensi yang tidak valid {0} {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +167,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) tidak dapat lebih besar dari jumlah yang direncanakan ({2}) di Order Produksi {3}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) tidak dapat lebih besar dari jumlah yang direncanakan ({2}) di Perintah Produksi {3}
 DocType: Shipping Rule,Shipping Rule Label,Peraturan Pengiriman Label
+DocType: Journal Entry Account,Payroll Entry,Entri Penggajian
 apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Forum pengguna
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +305,Raw Materials cannot be blank.,Bahan baku tidak boleh kosong.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +488,"Could not update stock, invoice contains drop shipping item.","Tidak bisa perbarui persediaan, faktur berisi barang titipan."
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +308,Raw Materials cannot be blank.,Bahan baku tidak boleh kosong.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +492,"Could not update stock, invoice contains drop shipping item.","Tidak bisa perbarui persediaan, faktur berisi barang titipan."
 DocType: Lab Test Sample,Lab Test Sample,Sampel Uji Lab
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +484,Quick Journal Entry,Jurnal Entry Cepat
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +492,Quick Journal Entry,Jurnal Entry Cepat
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,Anda tidak dapat mengubah kurs jika BOM disebutkan atas tiap barang
 DocType: Restaurant,Invoice Series Prefix,Awalan Seri Faktur
 DocType: Employee,Previous Work Experience,Pengalaman Kerja Sebelumnya
 DocType: Stock Entry,For Quantity,Untuk Kuantitas
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Entrikan Planned Qty untuk Item {0} pada baris {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} tidak di-posting
-apps/erpnext/erpnext/config/stock.py +27,Requests for items.,Permintaan untuk item.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +102,Google Maps integration is not enabled,Integrasi Google Maps tidak diaktifkan
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,{0} {1} is not submitted,{0} {1} belum dikirim
 DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Order produksi yang terpisah akan dibuat untuk setiap item Stok Barang jadi.
+DocType: Member,Membership Expiry Date,Tanggal Kedaluwarsa Keanggotaan
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} harus negatif dalam dokumen retur
 ,Minutes to First Response for Issues,Menit ke Response Pertama untuk Masalah
 DocType: Purchase Invoice,Terms and Conditions1,Syarat dan Conditions1
-apps/erpnext/erpnext/public/js/setup_wizard.js +106,The name of the institute for which you are setting up this system.,Nama lembaga yang Anda menyiapkan sistem ini.
+apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,Nama lembaga yang Anda menyiapkan sistem ini.
 DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Pencatatan Akuntansi telah dibekukan sampai tanggal ini, tidak seorang pun yang bisa melakukan / memodifikasi pencatatan kecuali peran yang telah ditentukan di bawah ini."
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Harap menyimpan dokumen sebelum menghasilkan jadwal pemeliharaan
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Harga terbaru diperbarui di semua BOM
-DocType: Fee Schedule,Successful,Sukses
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Status proyek
 DocType: UOM,Check this to disallow fractions. (for Nos),Centang untuk melarang fraksi. (Untuk Nos)
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +423,The following Production Orders were created:,Berikut Pesanan Produksi diciptakan:
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +424,The following Production Orders were created:,Berikut Pesanan Produksi diciptakan:
 DocType: Student Admission Program,Naming Series (for Student Applicant),Penamaan Series (untuk Mahasiswa Pemohon)
 DocType: Delivery Note,Transporter Name,Transporter Nama
 DocType: Authorization Rule,Authorized Value,Nilai Disetujui
 DocType: BOM,Show Operations,Tampilkan Operasi
 ,Minutes to First Response for Opportunity,Menit ke Response Pertama untuk Peluang
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Jumlah Absen
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +794,Item or Warehouse for row {0} does not match Material Request,Item atau Gudang untuk baris {0} Material tidak cocok Permintaan
-apps/erpnext/erpnext/config/stock.py +194,Unit of Measure,Satuan Ukur
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +823,Item or Warehouse for row {0} does not match Material Request,Item atau Gudang untuk baris {0} Material tidak cocok Permintaan
+apps/erpnext/erpnext/config/stock.py +187,Unit of Measure,Satuan Ukur
 DocType: Fiscal Year,Year End Date,Tanggal Akhir Tahun
 DocType: Task Depends On,Task Depends On,Tugas Tergantung Pada
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +999,Opportunity,Peluang
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1024,Opportunity,Peluang
 ,Completed Production Orders,Order Produksi Selesai
 DocType: Operation,Default Workstation,Standar Workstation
 DocType: Notification Control,Expense Claim Approved Message,Beban Klaim Disetujui Pesan
 DocType: Payment Entry,Deductions or Loss,Pemotongan atau Rugi
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} tertutup
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +245,{0} {1} is closed,{0} {1} tertutup
 DocType: Email Digest,How frequently?,Seberapa sering?
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +57,Total Collected: {0},Total Dikumpulkan: {0}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Total Dikumpulkan: {0}
 DocType: Purchase Receipt,Get Current Stock,Dapatkan Persediaan saat ini
 apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Tree Bill of Material
 DocType: Student,Joining Date,Tanggal Bergabung
 ,Employees working on a holiday,Karyawan yang bekerja pada hari libur
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Hadir
 DocType: Project,% Complete Method,% Metode Lengkap
-apps/erpnext/erpnext/healthcare/setup.py +180,Drug,Obat
+apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Obat
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Tanggal mulai pemeliharaan tidak bisa sebelum tanggal pengiriman untuk Serial No {0}
 DocType: Production Order,Actual End Date,Tanggal Akhir Aktual
 DocType: BOM,Operating Cost (Company Currency),Biaya operasi (Perusahaan Mata Uang)
@@ -2631,12 +2816,12 @@
 DocType: Authorization Rule,Applicable To (Role),Berlaku Untuk (Peran)
 DocType: BOM Update Tool,Replace BOM,Ganti BOM
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Kode {0} sudah ada
-DocType: Stock Entry,Purpose,Tujuan
+DocType: Employee Advance,Purpose,Tujuan
 DocType: Company,Fixed Asset Depreciation Settings,Pengaturan Penyusutan Aset Tetap
 DocType: Item,Will also apply for variants unless overrridden,Juga akan berlaku untuk varian kecuali tertimpa
 DocType: Purchase Invoice,Advances,Advances
 DocType: Production Order,Manufacture against Material Request,Memproduksi terhadap Permintaan Bahan
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Kelompok Penilaian:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Kelompok Penilaian:
 DocType: Item Reorder,Request for,Meminta
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Menyetujui Pengguna tidak bisa sama dengan pengguna aturan yang Berlaku Untuk
 DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Harga dasar (sesuai UOM Persediaan)
@@ -2644,23 +2829,26 @@
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,Tinggalkan Tanpa Bayar tidak sesuai dengan catatan Cuti Aplikasi disetujui
 DocType: Campaign,Campaign-.####,Promosi-.####
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Langkah selanjutnya
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +769,Please supply the specified items at the best possible rates,Silakan memasok barang-barang tertentu dengan tarif terbaik
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +794,Please supply the specified items at the best possible rates,Silakan memasok barang-barang tertentu dengan tarif terbaik
+DocType: Membership,USD,USD
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Membuat Invoice
 DocType: Selling Settings,Auto close Opportunity after 15 days,Auto Peluang dekat setelah 15 hari
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +75,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Pesanan Pembelian tidak diizinkan untuk {0} karena kartu skor berdiri {1}.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +76,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Pesanan Pembelian tidak diizinkan untuk {0} karena kartu skor berdiri {1}.
 apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,akhir Tahun
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Penawaran/Prospek %
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +119,Contract End Date must be greater than Date of Joining,Kontrak Tanggal Akhir harus lebih besar dari Tanggal Bergabung
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,Kontrak Tanggal Akhir harus lebih besar dari Tanggal Bergabung
+DocType: Driver,Driver,Sopir
 DocType: Vital Signs,Nutrition Values,Nilai gizi
 DocType: Lab Test Template,Is billable,Apakah bisa ditagih
 DocType: Delivery Note,DN-,DN-
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}",Baik &quot;Jadwal Dokter&quot; dan Waktu Per Penunjukan &quot;harus ditetapkan untuk Dr {0}
 DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Seorang distributor pihak ketiga / agen / komisi agen / affiliate / reseller yang menjual produk-produk perusahaan untuk komisi.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} terhadap Purchase Order {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +374,{0} against Purchase Order {1},{0} terhadap Purchase Order {1}
 DocType: Patient,Patient Demographics,Demografi pasien
 DocType: Task,Actual Start Date (via Time Sheet),Aktual Mulai Tanggal (via Waktu Lembar)
 apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Ini adalah situs contoh auto-dihasilkan dari ERPNext
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Rentang Ageing 1
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +226,Total advance amount cannot be greater than total claimed amount,Jumlah uang muka total tidak boleh lebih besar dari jumlah total yang diklaim
 DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
 
 #### Note
@@ -2704,22 +2892,26 @@
  10. Menambah atau Dikurangi: Apakah Anda ingin menambah atau mengurangi pajak."
 DocType: Homepage,Homepage,Homepage
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Pilih Dokter ...
+DocType: Grant Application,Grant Application Details ,Berikan Rincian Aplikasi
 DocType: Purchase Receipt Item,Recd Quantity,Qty Diterima
-apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +57,Fee Records Created - {0},Biaya Rekaman Dibuat - {0}
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +59,Fee Records Created - {0},Biaya Rekaman Dibuat - {0}
 DocType: Asset Category Account,Asset Category Account,Aset Kategori Akun
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +117,Cannot produce more Item {0} than Sales Order quantity {1},Tidak dapat menghasilkan lebih Stok Barang {0} daripada kuantitas Sales Order {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Entri Persediaan {0} tidak terkirim
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Tidak dapat menghasilkan lebih Stok Barang {0} daripada kuantitas Sales Order {1}
+apps/erpnext/erpnext/stock/doctype/item/item.js +360,Select Attribute Values,Pilih Nilai Atribut
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +537,Stock Entry {0} is not submitted,Entri Persediaan {0} tidak terkirim
 DocType: Payment Reconciliation,Bank / Cash Account,Bank / Rekening Kas
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Next Contact By cannot be same as the Lead Email Address,Dikontak Oleh berikut tidak bisa sama dengan Alamat Email Prospek
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,Next Contact By cannot be same as the Lead Email Address,Dikontak Oleh berikut tidak bisa sama dengan Alamat Email Prospek
 DocType: Tax Rule,Billing City,Kota Penagihan
 DocType: Asset,Manual,panduan
 DocType: Salary Component Account,Salary Component Account,Akun Komponen Gaji
 DocType: Global Defaults,Hide Currency Symbol,Sembunyikan Mata Uang
-apps/erpnext/erpnext/config/accounts.py +338,"e.g. Bank, Cash, Credit Card","misalnya Bank, Kas, Kartu Kredit"
+apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informasi donor
+apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","misalnya Bank, Kas, Kartu Kredit"
 DocType: Lead Source,Source Name,sumber Nama
 DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Tekanan darah istirahat normal pada orang dewasa sekitar 120 mmHg sistolik, dan diastolik 80 mmHg, disingkat &quot;120/80 mmHg&quot;"
 DocType: Journal Entry,Credit Note,Nota Kredit
 DocType: Warranty Claim,Service Address,Alamat Layanan
+DocType: Asset Maintenance Task,Calibration,Kalibrasi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Mebel dan perlengkapan
 DocType: Item,Manufacture,Pembuatan
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Penyiapan Perusahaan
@@ -2731,8 +2923,9 @@
 DocType: Opportunity,Customer / Lead Name,Nama Pelanggan / Prospek
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Izin Tanggal tidak disebutkan
 apps/erpnext/erpnext/config/manufacturing.py +7,Production,Produksi
-DocType: Patient,Occupation,Pendudukan
+DocType: Guardian,Occupation,Pendudukan
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Row {0}: Tanggal awal harus sebelum Tanggal Akhir
+DocType: Crop,Planting Area,Luas Tanam
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Total (Qty)
 DocType: Installation Note Item,Installed Qty,Terpasang Qty
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Ini bisa jadi karena beberapa Alamat Email yang salah di
@@ -2742,25 +2935,25 @@
 DocType: Purchase Invoice,Is Paid,Telah dibayar
 DocType: Salary Structure,Total Earning,Total Penghasilan
 DocType: Purchase Receipt,Time at which materials were received,Waktu di mana bahan yang diterima
+DocType: Products Settings,Products per Page,Produk per Halaman
 DocType: Stock Ledger Entry,Outgoing Rate,Tingkat keluar
-apps/erpnext/erpnext/config/hr.py +228,Organization branch master.,Cabang master organisasi.
-apps/erpnext/erpnext/controllers/accounts_controller.py +280, or ,atau
+apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Cabang master organisasi.
+apps/erpnext/erpnext/controllers/accounts_controller.py +303, or ,atau
 DocType: Sales Order,Billing Status,Status Penagihan
 apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Laporkan Masalah
-apps/erpnext/erpnext/public/js/setup_wizard.js +28,Education (beta),Pendidikan (beta)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Beban utilitas
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-ke atas
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Journal Entri {1} tidak memiliki akun {2} atau sudah cocok dengan voucher lain
 DocType: Supplier Scorecard Criteria,Criteria Weight,Kriteria Berat
 DocType: Buying Settings,Default Buying Price List,Standar Membeli Daftar Harga
-DocType: Process Payroll,Salary Slip Based on Timesheet,Slip Gaji Berdasarkan Daftar Absen
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +113,No employee for the above selected criteria OR salary slip already created,Tidak ada karyawan untuk kriteria di atas yang dipilih ATAU Slip gaji sudah dibuat
+DocType: Payroll Entry,Salary Slip Based on Timesheet,Slip Gaji Berdasarkan Daftar Absen
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +19,Buying Rate,Tingkat pembelian
 DocType: Notification Control,Sales Order Message,Pesan Nota Penjualan
 apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Set Nilai Default seperti Perusahaan, Mata Uang, Tahun Anggaran Current, dll"
 DocType: Payment Entry,Payment Type,Jenis Pembayaran
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +131,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Silakan pilih Batch for Item {0}. Tidak dapat menemukan satu bets yang memenuhi persyaratan ini
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +140,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Silakan pilih Batch for Item {0}. Tidak dapat menemukan satu bets yang memenuhi persyaratan ini
 DocType: Hub Category,Parent Category,Kategori Induk
-DocType: Process Payroll,Select Employees,Pilih Karyawan
+DocType: Payroll Entry,Select Employees,Pilih Karyawan
 DocType: Opportunity,Potential Sales Deal,Kesepakatan potensial Penjualan
 DocType: Complaint,Complaints,Keluhan
 DocType: Payment Entry,Cheque/Reference Date,Cek / Tanggal Referensi
@@ -2769,7 +2962,7 @@
 DocType: Bank Reconciliation Detail,Payment Entry,Masuk pembayaran
 DocType: Item,Quality Parameters,Parameter Kualitas
 ,sales-browser,penjualan-browser
-apps/erpnext/erpnext/accounts/doctype/account/account.js +73,Ledger,Buku besar
+apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Buku besar
 DocType: Patient Medical Record,PMR-,PMR-
 DocType: Drug Prescription,Drug Code,Kode obat
 DocType: Target Detail,Target  Amount,Target Jumlah
@@ -2777,12 +2970,12 @@
 DocType: Shopping Cart Settings,Shopping Cart Settings,Pengaturan Keranjang Belanja
 DocType: Journal Entry,Accounting Entries,Entri Akuntansi
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Gandakan entri. Silakan periksa Peraturan Otorisasi {0}
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +29,Global POS Profile {0} already created for company {1},Global Profil POS {0} sudah dibuat untuk perusahaan {1}
+DocType: Journal Entry Account,Reference Due Date,Tanggal Jatuh Tempo Referensi
 DocType: Purchase Order,Ref SQ,Ref SQ
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,dokumen tanda terima harus diserahkan
 DocType: Purchase Invoice Item,Received Qty,Qty Diterima
 DocType: Stock Entry Detail,Serial No / Batch,Serial No / Batch
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +320,Not Paid and Not Delivered,Tidak Dibayar dan tidak Terkirim
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Tidak Dibayar dan tidak Terkirim
 DocType: Product Bundle,Parent Item,Induk Stok Barang
 DocType: Account,Account Type,Jenis Account
 DocType: Delivery Note,DN-RET-,DN-RET-
@@ -2791,32 +2984,35 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Jadwal pemeliharaan tidak dihasilkan untuk semua item. Silahkan klik 'Menghasilkan Jadwal'
 ,To Produce,Untuk Menghasilkan
 apps/erpnext/erpnext/config/hr.py +93,Payroll,Daftar gaji
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +179,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Untuk baris {0} di {1}. Untuk menyertakan {2} di tingkat Item, baris {3} juga harus disertakan"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Untuk baris {0} di {1}. Untuk menyertakan {2} di tingkat Item, baris {3} juga harus disertakan"
 apps/erpnext/erpnext/utilities/activation.py +101,Make User,membuat Pengguna
 DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikasi paket untuk pengiriman (untuk mencetak)
 DocType: Bin,Reserved Quantity,Reserved Kuantitas
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Harap masukkan alamat email yang benar
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +654,Please select an item in the cart,Harap pilih item di keranjang
+DocType: Volunteer Skill,Volunteer Skill,Keterampilan Relawan
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +713,Please select an item in the cart,Harap pilih item di keranjang
 DocType: Landed Cost Voucher,Purchase Receipt Items,Nota Penerimaan Produk
 apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Menyesuaikan Bentuk
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +70,Arrear,tunggakan
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Depreciation Amount during the period,Penyusutan Jumlah selama periode tersebut
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,tunggakan
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Penyusutan Jumlah selama periode tersebut
 apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,Template cacat tidak harus template default
 DocType: Account,Income Account,Akun Penghasilan
 DocType: Payment Request,Amount in customer's currency,Jumlah dalam mata uang pelanggan
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +776,Delivery,Pengiriman
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +823,Delivery,Pengiriman
+DocType: Volunteer,Weekdays,Hari kerja
 DocType: Stock Reconciliation Item,Current Qty,Jumlah saat ini
 DocType: Restaurant Menu,Restaurant Menu,Menu Restoran
 apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Sebelumnya
 DocType: Appraisal Goal,Key Responsibility Area,Key Responsibility area
 apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Batch Student membantu Anda melacak kehadiran, penilaian dan biaya untuk siswa"
 DocType: Payment Entry,Total Allocated Amount,Jumlah Total Dialokasikan
-apps/erpnext/erpnext/setup/doctype/company/company.py +143,Set default inventory account for perpetual inventory,Tetapkan akun inventaris default untuk persediaan perpetual
+apps/erpnext/erpnext/setup/doctype/company/company.py +140,Set default inventory account for perpetual inventory,Tetapkan akun inventaris default untuk persediaan perpetual
 DocType: Item Reorder,Material Request Type,Permintaan Jenis Bahan
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +268,Accural Journal Entry for salaries from {0} to {1},Accural Journal masuk untuk gaji dari {0} ke {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +824,"LocalStorage is full, did not save","LocalStorage penuh, tidak menyimpan"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +85,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM Faktor Konversi adalah wajib
-apps/erpnext/erpnext/utilities/user_progress.py +214,Room Capacity,Kapasitas Kamar
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural Journal masuk untuk gaji dari {0} ke {1}
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Kirim Email Peninjauan Hibah
+apps/erpnext/erpnext/accounts/page/pos/pos.js +839,"LocalStorage is full, did not save","LocalStorage penuh, tidak menyimpan"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +90,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM Faktor Konversi adalah wajib
+apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Kapasitas Kamar
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref
 DocType: Lab Test,LP-,LP-
 DocType: Healthcare Settings,Registration Fee,Biaya pendaftaran
@@ -2830,16 +3026,17 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Rule harga dibuat untuk menimpa Daftar Harga / mendefinisikan persentase diskon, berdasarkan beberapa kriteria."
 DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Gudang hanya dapat diubah melalui Entri Persediaan / Nota Pengiriman / Nota Pembelian
 DocType: Employee Education,Class / Percentage,Kelas / Persentase
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +130,Head of Marketing and Sales,Kepala Pemasaran dan Penjualan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +68,Income Tax,Pajak Penghasilan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Kepala Pemasaran dan Penjualan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Pajak Penghasilan
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Jika Aturan Harga yang dipilih dibuat untuk 'Harga', itu akan menimpa Daftar Harga. Harga Rule harga adalah harga akhir, sehingga tidak ada diskon lebih lanjut harus diterapkan. Oleh karena itu, dalam transaksi seperti Sales Order, Purchase Order dll, maka akan diambil di lapangan 'Tingkat', daripada lapangan 'Daftar Harga Tingkat'."
 apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Lacak Prospek menurut Jenis Industri.
+apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Pergi ke kop surat
 DocType: Item Supplier,Item Supplier,Item Supplier
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1107,Please enter Item Code to get batch no,Entrikan Item Code untuk mendapatkan bets tidak
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +827,Please select a value for {0} quotation_to {1},Silakan pilih nilai untuk {0} quotation_to {1}
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1187,Please enter Item Code to get batch no,Entrikan Item Code untuk mendapatkan bets tidak
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +874,Please select a value for {0} quotation_to {1},Silakan pilih nilai untuk {0} quotation_to {1}
 apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Semua Alamat
 DocType: Company,Stock Settings,Pengaturan Persediaan
-apps/erpnext/erpnext/accounts/doctype/account/account.py +199,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Penggabungan ini hanya mungkin jika sifat berikut yang sama di kedua catatan. Apakah Group, Akar Jenis, Perusahaan"
+apps/erpnext/erpnext/accounts/doctype/account/account.py +185,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Penggabungan ini hanya mungkin jika sifat berikut yang sama di kedua catatan. Apakah Group, Akar Jenis, Perusahaan"
 DocType: Vehicle,Electric,listrik
 DocType: Task,% Progress,% Selesai
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Laba / Rugi Asset Disposal
@@ -2852,10 +3049,11 @@
 DocType: Leave Control Panel,Leave Control Panel,Cuti Control Panel
 DocType: Project,Task Completion,tugas Penyelesaian
 apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Tidak tersedia
+DocType: Volunteer,Volunteer Skills,Keterampilan Relawan
 DocType: Appraisal,HR User,HR Pengguna
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +53,POS?,POS?
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,POS?,POS?
 DocType: Purchase Invoice,Taxes and Charges Deducted,Pajak dan Biaya Dikurangi
-apps/erpnext/erpnext/hooks.py +138,Issues,Isu
+apps/erpnext/erpnext/hooks.py +142,Issues,Isu
 apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status harus menjadi salah satu {0}
 DocType: Sales Invoice,Debit To,Debit Untuk
 DocType: Restaurant Menu Item,Restaurant Menu Item,Item Menu Restoran
@@ -2863,60 +3061,62 @@
 DocType: Stock Ledger Entry,Actual Qty After Transaction,Jumlah Aktual Setelah Transaksi
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},Tidak ada slip gaji ditemukan antara {0} dan {1}
 ,Pending SO Items For Purchase Request,Pending SO Items Untuk Pembelian Permintaan
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +35,Student Admissions,Penerimaan Mahasiswa
-apps/erpnext/erpnext/accounts/party.py +364,{0} {1} is disabled,{0} {1} dinonaktifkan
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Penerimaan Mahasiswa
+apps/erpnext/erpnext/accounts/party.py +376,{0} {1} is disabled,{0} {1} dinonaktifkan
 DocType: Supplier,Billing Currency,Mata Uang Penagihan
 DocType: Sales Invoice,SINV-RET-,SINV-RET-
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +196,Extra Large,Ekstra Besar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Ekstra Besar
+DocType: Crop,Scientific Name,Nama ilmiah
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Jumlah Daun
 DocType: Consultation,In print,Di cetak
 ,Profit and Loss Statement,Laba Rugi
 DocType: Bank Reconciliation Detail,Cheque Number,Nomor Cek
 ,Sales Browser,Browser Penjualan
 DocType: Journal Entry,Total Credit,Jumlah Kredit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Peringatan: Ada {0} # {1} lain terhadap entri persediaan {2}
-apps/erpnext/erpnext/utilities/user_progress_utils.py +51,Local,[Daerah
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +540,Warning: Another {0} # {1} exists against stock entry {2},Peringatan: Ada {0} # {1} lain terhadap entri persediaan {2}
+apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,[Daerah
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Pinjaman Uang Muka dan (Aset)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Debitur
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +195,Large,Besar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Besar
 DocType: Homepage Featured Product,Homepage Featured Product,Homepage Produk Pilihan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +236,All Assessment Groups,Semua Grup Assessment
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +246,All Assessment Groups,Semua Grup Assessment
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Gudang baru Nama
 apps/erpnext/erpnext/accounts/report/financial_statements.py +233,Total {0} ({1}),Total {0} ({1})
 DocType: C-Form Invoice Detail,Territory,Wilayah
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Harap menyebutkan tidak ada kunjungan yang diperlukan
 DocType: Stock Settings,Default Valuation Method,Metode Perhitungan Standar
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +26,Fee,Biaya
-apps/erpnext/erpnext/setup/doctype/company/company.js +124,Update in progress. It might take a while.,Update sedang berlangsung. Mungkin butuh beberapa saat.
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Biaya
+apps/erpnext/erpnext/setup/doctype/company/company.js +125,Update in progress. It might take a while.,Update sedang berlangsung. Mungkin butuh beberapa saat.
 DocType: Vehicle Log,Fuel Qty,BBM Qty
 DocType: Production Order Operation,Planned Start Time,Rencana Start Time
 DocType: Course,Assessment,Penilaian
 DocType: Payment Entry Reference,Allocated,Dialokasikan
-apps/erpnext/erpnext/config/accounts.py +275,Close Balance Sheet and book Profit or Loss.,Tutup Neraca dan Perhitungan Laba Rugi atau buku.
+apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Tutup Neraca dan Perhitungan Laba Rugi atau buku.
 DocType: Student Applicant,Application Status,Status aplikasi
 DocType: Sensitivity Test Items,Sensitivity Test Items,Item Uji Sensitivitas
 DocType: Fees,Fees,biaya
 DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Tentukan Nilai Tukar untuk mengkonversi satu mata uang ke yang lain
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +158,Quotation {0} is cancelled,Quotation {0} dibatalkan
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Quotation {0} dibatalkan
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Jumlah Total Outstanding
 DocType: Sales Partner,Targets,Target
 DocType: Price List,Price List Master,Daftar Harga Guru
 DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Semua Transaksi Penjualan dapat ditandai terhadap beberapa ** Orang Penjualan ** sehingga Anda dapat mengatur dan memonitor target.
 ,S.O. No.,SO No
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +199,Please create Customer from Lead {0},Silakan membuat Pelanggan dari Prospek {0}
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Silakan membuat Pelanggan dari Prospek {0}
 apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Pilih pasien
 DocType: Price List,Applicable for Countries,Berlaku untuk Negara
 DocType: Supplier Scorecard Scoring Variable,Parameter Name,Nama parameter
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Hanya Tinggalkan Aplikasi status &#39;Disetujui&#39; dan &#39;Ditolak&#39; dapat disampaikan
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Mahasiswa Nama Group adalah wajib berturut-turut {0}
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Mahasiswa Nama Group adalah wajib berturut-turut {0}
 DocType: Homepage,Products to be shown on website homepage,Produk yang akan ditampilkan pada homepage website
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Ini adalah kelompok pelanggan paling dasar dan tidak dapat diedit.
-DocType: Employee,AB-,AB-
+DocType: Student,AB-,AB-
 DocType: POS Profile,Ignore Pricing Rule,Abaikan Aturan Harga
 DocType: Employee Education,Graduate,Lulusan
 DocType: Leave Block List,Block Days,Blok Hari
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Alamat Pengiriman tidak memiliki negara, yang diperlukan untuk Aturan Pengiriman ini"
 DocType: Journal Entry,Excise Entry,Cukai Entri
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +64,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Peringatan: Order Penjualan {0} sudah ada untuk Order Pembelian Pelanggan {1}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Peringatan: Order Penjualan {0} sudah ada untuk Order Pembelian Pelanggan {1}
 DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
 
 Examples:
@@ -2930,54 +3130,56 @@
 1. Terms of shipping, if applicable.
 1. Ways of addressing disputes, indemnity, liability, etc.
 1. Address and Contact of your Company.","Syarat dan Ketentuan Standar yang dapat ditambahkan ke Penjualan dan Pembelian. Contoh : 1. Validitas tawaran. 1. Termin Pembayaran (Pembayaran Dimuka, Secara Kredit, pembayaran dimuka sebagian, dll). 1. Apa yang ekstra (atau dibayar oleh Pelanggan). 1. Peringatan keamanan / penggunaan. 1. Garansi jika ada. 1. Kebijakan Retur. 1. Syarat pengiriman, jika berlaku. 1. Cara menangani sengketa, ganti rugi, kewajiban, dll. 1. Alamat dan Kontak Perusahaan Anda."
+DocType: Issue,Issue Type,Jenis Isu
 DocType: Attendance,Leave Type,Cuti Type
 DocType: Purchase Invoice,Supplier Invoice Details,Pemasok Rincian Faktur
+DocType: Agriculture Task,Ignore holidays,Abaikan hari libur
 apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Beban akun / Difference ({0}) harus akun 'Laba atau Rugi'
 DocType: Project,Copied From,Disalin dari
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Nama error: {0}
 apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Shortage,Kekurangan
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not associated with {2} {3},{0} {1} tidak terkait dengan {2} {3}
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Kehadiran bagi karyawan {0} sudah ditandai
 DocType: Packing Slip,If more than one package of the same type (for print),Jika lebih dari satu paket dari jenis yang sama (untuk mencetak)
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Harap tetapkan pelanggan default di Pengaturan Restoran
 ,Salary Register,Register Gaji
 DocType: Warehouse,Parent Warehouse,Gudang tua
 DocType: C-Form Invoice Detail,Net Total,Jumlah Bersih
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +498,Default BOM not found for Item {0} and Project {1},Default BOM tidak ditemukan untuk Item {0} dan Project {1}
-apps/erpnext/erpnext/config/hr.py +163,Define various loan types,Mendefinisikan berbagai jenis pinjaman
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +526,Default BOM not found for Item {0} and Project {1},Default BOM tidak ditemukan untuk Item {0} dan Project {1}
+apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Mendefinisikan berbagai jenis pinjaman
 DocType: Bin,FCFS Rate,FCFS Tingkat
-DocType: Payment Reconciliation Invoice,Outstanding Amount,Jumlah belum terbayar
+DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Jumlah belum terbayar
 apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Waktu (dalam menit)
 DocType: Project Task,Working,Kerja
 DocType: Stock Ledger Entry,Stock Queue (FIFO),Antrian Persediaan (FIFO)
-apps/erpnext/erpnext/public/js/setup_wizard.js +124,Financial Year,Tahun Keuangan
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +41,{0} does not belong to Company {1},{0} bukan milik Perusahaan {1}
+apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Tahun Keuangan
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} bukan milik Perusahaan {1}
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,Tidak dapat memecahkan kriteria fungsi skor untuk {0}. Pastikan rumusnya benar.
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +119,Cost as on,Biaya seperti pada
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Biaya seperti pada
 DocType: Healthcare Settings,Out Patient Settings,Keluar Pengaturan Pasien
 DocType: Account,Round Off,Membulatkan
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +231,Quantity must be positive,Kuantitas harus positif
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +252,Quantity must be positive,Kuantitas harus positif
 ,Requested Qty,Diminta Qty
 DocType: Tax Rule,Use for Shopping Cart,Gunakan untuk Keranjang Belanja
 apps/erpnext/erpnext/controllers/item_variant.py +96,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Nilai {0} untuk Atribut {1} tidak ada dalam daftar Barang valid Atribut Nilai untuk Item {2}
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +78,Select Serial Numbers,Pilih Nomor Seri
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Pilih Nomor Seri
 DocType: BOM Item,Scrap %,Scrap%
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Biaya akan didistribusikan secara proporsional berdasarkan pada item qty atau jumlah, sesuai pilihan Anda"
 DocType: Maintenance Visit,Purposes,Tujuan
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Atleast satu item harus dimasukkan dengan kuantitas negatif dalam dokumen kembali
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operasi {0} lebih lama daripada jam kerja yang tersedia di workstation {1}, memecah operasi menjadi beberapa operasi"
+DocType: Membership,Membership Status,Status Keanggotaan
 ,Requested,Diminta
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,No Remarks,Tidak ada Keterangan
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Tidak ada Keterangan
+DocType: Asset,In Maintenance,Dalam perawatan
 DocType: Purchase Invoice,Overdue,Terlambat
 DocType: Account,Stock Received But Not Billed,Persediaan Diterima Tapi Tidak Ditagih
-apps/erpnext/erpnext/accounts/doctype/account/account.py +87,Root Account must be a group,Akar Rekening harus kelompok
+apps/erpnext/erpnext/accounts/doctype/account/account.py +86,Root Account must be a group,Akar Rekening harus kelompok
 DocType: Consultation,Drug Prescription,Resep obat
 DocType: Fees,FEE.,BIAYA.
 DocType: Employee Loan,Repaid/Closed,Dilunasi / Ditutup
 DocType: Item,Total Projected Qty,Total Proyeksi Jumlah
 DocType: Monthly Distribution,Distribution Name,Nama Distribusi
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Supplier&gt; Supplier Type
-apps/erpnext/erpnext/stock/stock_ledger.py +464,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Angka penilaian tidak ditemukan untuk Item {0}, yang diperlukan untuk melakukan entri akuntansi untuk {1} {2}. Jika item tersebut bertransaksi sebagai item angka penilaian nol di {1}, mohon sebutkan di tabel Item {1}. Jika tidak, buat transaksi saham masuk untuk item tersebut atau beri nilai valuasi dalam catatan Item, lalu coba kirimkan / batalkan entri ini."
+apps/erpnext/erpnext/stock/stock_ledger.py +471,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Angka penilaian tidak ditemukan untuk Item {0}, yang diperlukan untuk melakukan entri akuntansi untuk {1} {2}. Jika item tersebut bertransaksi sebagai item angka penilaian nol di {1}, mohon sebutkan di tabel Item {1}. Jika tidak, buat transaksi saham masuk untuk item tersebut atau beri nilai valuasi dalam catatan Item, lalu coba kirimkan / batalkan entri ini."
 DocType: Course,Course Code,Kode Course
 apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},Inspeksi Mutu diperlukan untuk Item {0}
 DocType: POS Settings,Use POS in Offline Mode,Gunakan POS dalam Mode Offline
@@ -2988,20 +3190,20 @@
 apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Kelola Wilayah Tree.
 DocType: Journal Entry Account,Sales Invoice,Faktur Penjualan
 DocType: Journal Entry Account,Party Balance,Saldo Partai
-apps/erpnext/erpnext/accounts/page/pos/pos.js +484,Please select Apply Discount On,Silakan pilih Terapkan Diskon Pada
+apps/erpnext/erpnext/accounts/page/pos/pos.js +497,Please select Apply Discount On,Silakan pilih Terapkan Diskon Pada
+DocType: Stock Settings,Sample Retention Warehouse,Contoh Retensi Gudang
 DocType: Company,Default Receivable Account,Standar Piutang Rekening
-DocType: Process Payroll,Create Bank Entry for the total salary paid for the above selected criteria,Buat Bank Entri untuk total gaji yang dibayarkan untuk kriteria di atas yang dipilih
 DocType: Physician,Physician Schedule,Jadwal dokter
 DocType: Purchase Invoice,Deemed Export,Dianggap ekspor
 DocType: Stock Entry,Material Transfer for Manufacture,Alih Material untuk Produksi
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Persentase Diskon dapat diterapkan baik terhadap Daftar Harga atau untuk semua List Price.
 DocType: Subscription,Half-yearly,Setengah tahun sekali
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +402,Accounting Entry for Stock,Entri Akuntansi untuk Persediaan
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +406,Accounting Entry for Stock,Entri Akuntansi untuk Persediaan
 DocType: Lab Test,LabTest Approver,Pendekatan LabTest
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Anda telah memberikan penilaian terhadap kriteria penilaian {}.
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Anda telah memberikan penilaian terhadap kriteria penilaian {}.
 DocType: Vehicle Service,Engine Oil,Oli mesin
 DocType: Sales Invoice,Sales Team1,Penjualan team1
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +39,Item {0} does not exist,Item {0} tidak ada
+apps/erpnext/erpnext/stock/doctype/item/item.py +521,Item {0} does not exist,Item {0} tidak ada
 DocType: Sales Invoice,Customer Address,Alamat Pelanggan
 DocType: Employee Loan,Loan Details,Detail pinjaman
 DocType: Company,Default Inventory Account,Akun Inventaris Default
@@ -3009,6 +3211,7 @@
 DocType: Antibiotic,Antibiotic Name,Nama Antibiotik
 DocType: Purchase Invoice,Apply Additional Discount On,Terapkan tambahan Diskon Pada
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Pilih Jenis ...
+DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,Tautan ke semua Unit Tanah tempat Tanaman tumbuh
 DocType: Account,Root Type,Akar Type
 DocType: Item,FIFO,FIFO
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Baris # {0}: Tidak dapat mengembalikan lebih dari {1} untuk Barang {2}
@@ -3016,21 +3219,23 @@
 DocType: Item Group,Show this slideshow at the top of the page,Tampilkan slide ini di bagian atas halaman
 DocType: BOM,Item UOM,Stok Barang UOM
 DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Jumlah pajak Setelah Diskon Jumlah (Perusahaan Mata Uang)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +150,Target warehouse is mandatory for row {0},Target gudang adalah wajib untuk baris {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +155,Target warehouse is mandatory for row {0},Target gudang adalah wajib untuk baris {0}
 DocType: Cheque Print Template,Primary Settings,Pengaturan utama
 DocType: Purchase Invoice,Select Supplier Address,Pilih Pemasok Alamat
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +380,Add Employees,Tambahkan Karyawan
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Tambahkan Karyawan
 DocType: Purchase Invoice Item,Quality Inspection,Inspeksi Mutu
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +192,Extra Small,Ekstra Kecil
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Ekstra Kecil
 DocType: Company,Standard Template,Template standar
 DocType: Training Event,Theory,Teori
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +780,Warning: Material Requested Qty is less than Minimum Order Qty,Peringatan: Material Diminta Qty kurang dari Minimum Order Qty
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +805,Warning: Material Requested Qty is less than Minimum Order Qty,Peringatan: Material Diminta Qty kurang dari Minimum Order Qty
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Akun {0} dibekukan
 DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Badan Hukum / Anak dengan Bagan terpisah Account milik Organisasi.
 DocType: Payment Request,Mute Email,Diamkan Surel
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +29,"Food, Beverage & Tobacco","Makanan, Minuman dan Tembakau"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +689,Can only make payment against unbilled {0},Hanya dapat melakukan pembayaran terhadap yang belum ditagihkan {0}
-apps/erpnext/erpnext/controllers/selling_controller.py +130,Commission rate cannot be greater than 100,Tingkat komisi tidak dapat lebih besar dari 100
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Makanan, Minuman dan Tembakau"
+DocType: Account,Account Number,Nomor akun
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +714,Can only make payment against unbilled {0},Hanya dapat melakukan pembayaran terhadap yang belum ditagihkan {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +98,Commission rate cannot be greater than 100,Tingkat komisi tidak dapat lebih besar dari 100
+DocType: Volunteer,Volunteer,Sukarelawan
 DocType: Stock Entry,Subcontract,Kontrak tambahan
 apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,Entrikan {0} terlebih dahulu
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +87,No replies from,Tidak ada balasan dari
@@ -3039,60 +3244,68 @@
 DocType: Item,Manufacturer Part Number,Produsen Part Number
 DocType: Production Order Operation,Estimated Time and Cost,Perkiraan Waktu dan Biaya
 DocType: Bin,Bin,Tong Sampah
+DocType: Crop,Crop Name,Nama tanaman
 DocType: SMS Log,No of Sent SMS,Tidak ada dari Sent SMS
 DocType: Antibiotic,Healthcare Administrator,Administrator Kesehatan
 apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Tetapkan Target
 DocType: Dosage Strength,Dosage Strength,Kekuatan Dosis
 DocType: Account,Expense Account,Beban Akun
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,Perangkat lunak
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +199,Colour,Warna
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Perangkat lunak
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Warna
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteria Rencana Penilaian
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Cegah Pesanan Pembelian
-apps/erpnext/erpnext/healthcare/setup.py +257,Susceptible,Rentan
+apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,Rentan
 DocType: Patient Appointment,Scheduled,Dijadwalkan
 apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Meminta kutipan.
 apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Silahkan pilih barang yang ""Barang Stok"" nya  ""Tidak"" dan ""Barang Jualan"" nya ""Ya"", serta tidak ada Bundel Produk lainnya"
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Pilih pelanggan
 DocType: Student Log,Academic,Akademis
 DocType: Patient,Personal and Social History,Sejarah Pribadi dan Sosial
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +52,User {0} created,Pengguna {0} dibuat
 DocType: Fee Schedule,Fee Breakup for each student,Fee Breakup untuk setiap siswa
-apps/erpnext/erpnext/controllers/accounts_controller.py +476,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Total muka ({0}) terhadap Orde {1} tidak dapat lebih besar dari Grand Total ({2})
+apps/erpnext/erpnext/controllers/accounts_controller.py +520,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Total muka ({0}) terhadap Orde {1} tidak dapat lebih besar dari Grand Total ({2})
 DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Pilih Distribusi bulanan untuk merata mendistribusikan target di bulan.
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Ubah Kode
 DocType: Purchase Invoice Item,Valuation Rate,Tingkat Penilaian
 DocType: Stock Reconciliation,SR/,SR /
 DocType: Vehicle,Diesel,disel
-apps/erpnext/erpnext/stock/get_item_details.py +338,Price List Currency not selected,Daftar Harga Mata uang tidak dipilih
+apps/erpnext/erpnext/stock/get_item_details.py +381,Price List Currency not selected,Daftar Harga Mata uang tidak dipilih
 apps/erpnext/erpnext/config/healthcare.py +46,Results,hasil
 ,Student Monthly Attendance Sheet,Mahasiswa Lembar Kehadiran Bulanan
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Aturan pengiriman hanya berlaku untuk penjualan
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Karyawan {0} telah diterapkan untuk {1} antara {2} dan {3}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Tanggal Project Mulai
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +5,Until,Sampai
 DocType: Rename Tool,Rename Log,Log Riwayat Ganti Nama
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Student Group atau Jadwal Kursus adalah wajib
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Student Group atau Jadwal Kursus adalah wajib
 DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Samakan Jam Penagihan dan Jam Kerja di Daftar Absen
 DocType: Maintenance Visit Purpose,Against Document No,Terhadap No. Dokumen
 DocType: BOM,Scrap,Membatalkan
-apps/erpnext/erpnext/utilities/user_progress.py +196,Go to Instructors,Pergi ke instruktur
+apps/erpnext/erpnext/utilities/user_progress.py +214,Go to Instructors,Pergi ke instruktur
 apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Kelola Partner Penjualan
 DocType: Quality Inspection,Inspection Type,Tipe Inspeksi
 DocType: Fee Validity,Visited yet,Dikunjungi belum
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Gudang dengan transaksi yang ada tidak dapat dikonversi ke grup.
 DocType: Assessment Result Tool,Result HTML,hasil HTML
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Memeber Activity,Aktivitas Memeber
 apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Kadaluarsa pada
 apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Tambahkan Siswa
+apps/erpnext/erpnext/public/js/utils.js +264,Please select {0},Silahkan pilih {0}
 DocType: C-Form,C-Form No,C-Form ada
 DocType: BOM,Exploded_items,Pembesaran Item
-apps/erpnext/erpnext/utilities/user_progress.py +118,List your products or services that you buy or sell.,Cantumkan produk atau layanan yang Anda beli atau jual.
+apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,Cantumkan produk atau layanan yang Anda beli atau jual.
+DocType: Water Analysis,Storage Temperature,Suhu Penyimpanan
 DocType: Employee Attendance Tool,Unmarked Attendance,Kehadiran non-absen
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +133,Researcher,Peneliti
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Peneliti
 DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Pendaftaran Alat Mahasiswa
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Tanggal mulai harus kurang dari tanggal akhir untuk tugas {0}
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Nama atau Email adalah wajib
-apps/erpnext/erpnext/config/stock.py +168,Incoming quality inspection.,Pemeriksaan mutu barang masuk
 DocType: Purchase Order Item,Returned Qty,Qty Retur
-DocType: Employee,Exit,Keluar
-apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Root Type is mandatory,Tipe Dasar adalah wajib
+DocType: Student,Exit,Keluar
+apps/erpnext/erpnext/accounts/doctype/account/account.py +158,Root Type is mandatory,Tipe Dasar adalah wajib
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Gagal memasang prasetel
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} saat ini memiliki {1} posisi Supplier Scorecard, dan RFQs ke pemasok ini harus dikeluarkan dengan hati-hati."
+DocType: Chapter,Non Profit Manager,Manajer Non Profit
 DocType: BOM,Total Cost(Company Currency),Total Biaya (Perusahaan Mata Uang)
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,Serial ada {0} dibuat
 DocType: Homepage,Company Description for website homepage,Deskripsi Perusahaan untuk homepage website
@@ -3103,40 +3316,41 @@
 DocType: Employee,You can enter any date manually,Anda dapat memasukkan tanggal apapun secara manual
 DocType: Healthcare Settings,Result Printed,Hasil cetak
 DocType: Asset Category Account,Depreciation Expense Account,Akun Beban Penyusutan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +221,Probationary Period,Masa percobaan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Probationary Period,Masa percobaan
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Lihat {0}
 DocType: Customer Group,Only leaf nodes are allowed in transaction,Hanya node cuti yang diperbolehkan dalam transaksi
-DocType: Expense Claim,Expense Approver,Approver Klaim Biaya
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Baris {0}: Uang muka dari Pelanggan harus kredit
-apps/erpnext/erpnext/accounts/doctype/account/account.js +83,Non-Group to Group,Non-Group untuk Grup
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Batch wajib di baris {0}
+DocType: Project,Total Costing Amount (via Timesheets),Total Costing Amount (melalui Timesheets)
+DocType: Employee Advance,Expense Approver,Approver Klaim Biaya
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +134,Row {0}: Advance against Customer must be credit,Baris {0}: Uang muka dari Pelanggan harus kredit
+apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Non-Group untuk Grup
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Batch wajib di baris {0}
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Nota Penerimaan Stok Barang Disediakan
 DocType: Payment Entry,Pay,Membayar
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Untuk Datetime
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +54,Course Schedules deleted:,Jadwal Kursus dihapus:
 apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Log untuk mempertahankan status pengiriman sms
 DocType: Accounts Settings,Make Payment via Journal Entry,Lakukan Pembayaran via Journal Entri
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +86,Printed On,Printed On
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +97,Printed On,Printed On
 DocType: Item,Inspection Required before Delivery,Inspeksi Diperlukan sebelum Pengiriman
 DocType: Item,Inspection Required before Purchase,Inspeksi Diperlukan sebelum Pembelian
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Kegiatan Tertunda
 DocType: Patient Appointment,Reminded,Mengingatkan
 DocType: Patient,PID-,PID-
-apps/erpnext/erpnext/public/js/setup_wizard.js +103,Your Organization,Organisasi Anda
+DocType: Chapter Member,Chapter Member,Bab Anggota
+apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Organisasi Anda
 DocType: Fee Component,Fees Category,biaya Kategori
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Please enter relieving date.,Silahkan masukkan menghilangkan date.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Silahkan masukkan menghilangkan date.
 apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
 DocType: Supplier Scorecard,Notify Employee,Beritahu Karyawan
 DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Entrikan nama kampanye jika sumber penyelidikan adalah kampanye
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +38,Newspaper Publishers,Penerbit Koran
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Penerbit Koran
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Pilih Tahun Fiskal
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +114,Expected Delivery Date should be after Sales Order Date,Tanggal Pengiriman yang Diharapkan harus setelah Tanggal Pesanan Penjualan
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,Tanggal Pengiriman yang Diharapkan harus setelah Tanggal Pesanan Penjualan
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Tingkat Re-Order
 DocType: Company,Chart Of Accounts Template,Grafik Of Account Template
 DocType: Attendance,Attendance Date,Tanggal Kehadiran
-apps/erpnext/erpnext/stock/get_item_details.py +302,Item Price updated for {0} in Price List {1},Item Harga diperbarui untuk {0} di Daftar Harga {1}
+apps/erpnext/erpnext/stock/get_item_details.py +345,Item Price updated for {0} in Price List {1},Item Harga diperbarui untuk {0} di Daftar Harga {1}
 DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Gaji perpisahan berdasarkan Produktif dan Pengurangan.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +131,Account with child nodes cannot be converted to ledger,Akun dengan node anak tidak dapat dikonversi ke buku besar
+apps/erpnext/erpnext/accounts/doctype/account/account.py +130,Account with child nodes cannot be converted to ledger,Akun dengan node anak tidak dapat dikonversi ke buku besar
 DocType: Purchase Invoice Item,Accepted Warehouse,Gudang Barang Diterima
 DocType: Bank Reconciliation Detail,Posting Date,Tanggal Posting
 DocType: Item,Valuation Method,Metode Perhitungan
@@ -3145,15 +3359,15 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +85,Duplicate entry,Entri Ganda/Duplikat
 DocType: Program Enrollment Tool,Get Students,Dapatkan Siswa
 DocType: Serial No,Under Warranty,Masih Garansi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +491,[Error],[Kesalahan]
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +515,[Error],[Kesalahan]
 DocType: Sales Order,In Words will be visible once you save the Sales Order.,Dalam Kata-kata akan terlihat setelah Anda menyimpan Sales Order.
 ,Employee Birthday,Ulang Tahun Karyawan
+apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Silakan pilih Tanggal Penyelesaian untuk Perbaikan Selesai
 DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Alat Batch Kehadiran mahasiswa
 apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,batas Dilalui
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Terjadwal Upto
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,Modal Ventura
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Istilah akademik dengan ini &#39;Tahun Akademik&#39; {0} dan &#39;Nama Term&#39; {1} sudah ada. Harap memodifikasi entri ini dan coba lagi.
-apps/erpnext/erpnext/stock/doctype/item/item.py +474,"As there are existing transactions against item {0}, you can not change the value of {1}","Karena ada transaksi yang ada terhadap barang {0}, Anda tidak dapat mengubah nilai {1}"
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Terjadwal Upto
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Modal Ventura
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Istilah akademik dengan ini &#39;Tahun Akademik&#39; {0} dan &#39;Nama Term&#39; {1} sudah ada. Harap memodifikasi entri ini dan coba lagi.
 DocType: UOM,Must be Whole Number,Harus Nomor Utuh
 DocType: Leave Control Panel,New Leaves Allocated (In Days),cuti baru Dialokasikan (Dalam Hari)
 DocType: Purchase Invoice,Invoice Copy,Salinan faktur
@@ -3163,7 +3377,7 @@
 DocType: Payment Reconciliation Invoice,Invoice Number,Nomor Faktur
 DocType: Shopping Cart Settings,Orders,Order
 DocType: Employee Leave Approver,Leave Approver,Approver Cuti
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +272,Please select a batch,Silakan pilih satu batch
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,Silakan pilih satu batch
 DocType: Assessment Group,Assessment Group Name,Nama penilaian Grup
 DocType: Manufacturing Settings,Material Transferred for Manufacture,Bahan Ditransfer untuk Produksi
 DocType: Expense Claim,"A user with ""Expense Approver"" role","Pengguna dengan peran ""Expense Approver"""
@@ -3172,21 +3386,23 @@
 ,Issued Items Against Production Order,Tahun Produk Terhadap Orde Produksi
 DocType: Antibiotic,Healthcare,Kesehatan
 DocType: Target Detail,Target Detail,Sasaran Detil
+apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Varian tunggal
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Semua Jobs
 DocType: Sales Order,% of materials billed against this Sales Order,% Bahan ditagih terhadap Sales Order ini
 DocType: Program Enrollment,Mode of Transportation,Cara Transportasi
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Periode Penutupan Entri
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Pilih Departemen ...
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Biaya Center dengan transaksi yang ada tidak dapat dikonversi ke grup
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +360,Amount {0} {1} {2} {3},Jumlah {0} {1} {2} {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +361,Amount {0} {1} {2} {3},Jumlah {0} {1} {2} {3}
 DocType: Account,Depreciation,Penyusutan
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Supplier (s)
 DocType: Employee Attendance Tool,Employee Attendance Tool,Alat Absensi Karyawan
 DocType: Guardian Student,Guardian Student,wali Mahasiswa
 DocType: Supplier,Credit Limit,Batas Kredit
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Rata-rata Tarif Daftar Harga Jual
 DocType: Production Plan Sales Order,Salse Order Date,Salse Urutan Tanggal
 DocType: Salary Component,Salary Component,Komponen gaji
-apps/erpnext/erpnext/accounts/utils.py +490,Payment Entries {0} are un-linked,Entries pembayaran {0} adalah un-linked
+apps/erpnext/erpnext/accounts/utils.py +492,Payment Entries {0} are un-linked,Entries pembayaran {0} adalah un-linked
 DocType: GL Entry,Voucher No,Voucher Tidak ada
 ,Lead Owner Efficiency,Efisiensi Pemilik Prospek
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +195,Most Popular,Paling populer
@@ -3199,12 +3415,12 @@
 apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Template istilah atau kontrak.
 DocType: Purchase Invoice,Address and Contact,Alamat dan Kontak
 DocType: Cheque Print Template,Is Account Payable,Apakah Account Payable
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +273,Stock cannot be updated against Purchase Receipt {0},Persediaan tidak dapat diperbarui terhadap Nota Pembelian {0}
-DocType: Supplier,Last Day of the Next Month,Hari terakhir dari Bulan Depan
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Persediaan tidak dapat diperbarui terhadap Nota Pembelian {0}
+DocType: Company,Last Day of the Next Month,Hari terakhir dari Bulan Depan
 DocType: Support Settings,Auto close Issue after 7 days,Auto Issue dekat setelah 7 hari
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Cuti tidak dapat dialokasikan sebelum {0}, saldo cuti sudah pernah membawa-diteruskan dalam catatan alokasi cuti masa depan {1}"
-apps/erpnext/erpnext/accounts/party.py +319,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Catatan: Tanggal Jatuh Tempo / Referensi melebihi {0} hari dari yang diperbolehkan untuk kredit pelanggan
-apps/erpnext/erpnext/schools/doctype/program/program.js +8,Student Applicant,Mahasiswa Pemohon
+apps/erpnext/erpnext/accounts/party.py +320,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Catatan: Tanggal Jatuh Tempo / Referensi melebihi {0} hari dari yang diperbolehkan untuk kredit pelanggan
+apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,Mahasiswa Pemohon
 DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL UNTUK RECIPIENT
 DocType: Asset Category Account,Accumulated Depreciation Account,Akun Penyusutan Akumulasi
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Email ini otomatis terkirim
@@ -3215,38 +3431,41 @@
 DocType: Activity Cost,Billing Rate,Tarip penagihan
 ,Qty to Deliver,Kuantitas Pengiriman
 ,Stock Analytics,Analisis Persediaan
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +505,Operations cannot be left blank,Operasi tidak dapat dibiarkan kosong
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +508,Operations cannot be left blank,Operasi tidak dapat dibiarkan kosong
 DocType: Maintenance Visit Purpose,Against Document Detail No,Terhadap Detail Dokumen No.
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +98,Party Type is mandatory,Partai Type adalah wajib
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +99,Party Type is mandatory,Partai Type adalah wajib
 DocType: Quality Inspection,Outgoing,Keluaran
 DocType: Material Request,Requested For,Diminta Untuk
 DocType: Quotation Item,Against Doctype,Terhadap Doctype
-apps/erpnext/erpnext/controllers/buying_controller.py +395,{0} {1} is cancelled or closed,{0} {1} dibatalkan atau ditutup
+apps/erpnext/erpnext/controllers/buying_controller.py +396,{0} {1} is cancelled or closed,{0} {1} dibatalkan atau ditutup
+DocType: Asset,Calculate Depreciation,Hitung Depresiasi
 DocType: Delivery Note,Track this Delivery Note against any Project,Lacak Pengiriman ini Catatan terhadap Proyek manapun
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Kas Bersih dari Investasi
 DocType: Production Order,Work-in-Progress Warehouse,Gudang Work In Progress
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Aset {0} harus diserahkan
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Aset {0} harus diserahkan
 DocType: Fee Schedule Program,Total Students,Jumlah Siswa
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Kehadiran Rekam {0} ada terhadap Mahasiswa {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Referensi # {0} tanggal {1}
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +161,Depreciation Eliminated due to disposal of assets,Penyusutan Dieliminasi karena pelepasan aset
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Kehadiran Rekam {0} ada terhadap Mahasiswa {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +352,Reference #{0} dated {1},Referensi # {0} tanggal {1}
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Penyusutan Dieliminasi karena pelepasan aset
+DocType: Member,Member,Anggota
 apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Pengelolaan Alamat
-DocType: Asset,Item Code,Kode Item
+DocType: Pricing Rule,Item Code,Kode Item
 DocType: Production Planning Tool,Create Production Orders,Buat Order Produksi
 DocType: Serial No,Warranty / AMC Details,Garansi / Detail AMC
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Pilih siswa secara manual untuk Activity based Group
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Pilih siswa secara manual untuk Activity based Group
 DocType: Journal Entry,User Remark,Keterangan Pengguna
 DocType: Lead,Market Segment,Segmen Pasar
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +924,Paid Amount cannot be greater than total negative outstanding amount {0},Dibayar Jumlah tidak dapat lebih besar dari jumlah total outstanding negatif {0}
+DocType: Crop,Agriculture Manager,Manajer Pertanian
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},Dibayar Jumlah tidak dapat lebih besar dari jumlah total outstanding negatif {0}
 DocType: Supplier Scorecard Period,Variables,Variabel
 DocType: Employee Internal Work History,Employee Internal Work History,Riwayat Kerja Karyawan Internal
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +239,Closing (Dr),Penutup (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Dr),Penutup (Dr)
 DocType: Cheque Print Template,Cheque Size,Cek Ukuran
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,No. Seri {0} tidak tersedia
 apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Template Pajak transaksi penjualan
 DocType: Sales Invoice,Write Off Outstanding Amount,Write Off Jumlah Outstanding
 apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Akun {0} tidak cocok dengan Perusahaan {1}
-DocType: School Settings,Current Academic Year,Tahun Akademik Saat Ini
+DocType: Education Settings,Current Academic Year,Tahun Akademik Saat Ini
 DocType: Stock Settings,Default Stock UOM,UOM Persediaan Standar
 DocType: Asset,Number of Depreciations Booked,Jumlah Penyusutan Dipesan
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Terhadap Pinjaman Karyawan: {0}
@@ -3254,49 +3473,54 @@
 DocType: Production Planning Tool,Create Material Requests,Buat Order Permintaan Material
 DocType: Employee Education,School/University,Sekolah / Universitas
 DocType: Payment Request,Reference Details,Detail referensi
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Nilai diharapkan Setelah Hidup Berguna harus kurang dari Gross Jumlah Pembelian
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Nilai diharapkan Setelah Hidup Berguna harus kurang dari Gross Jumlah Pembelian
 DocType: Sales Invoice Item,Available Qty at Warehouse,Jumlah Tersedia di Gudang
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Nilai Tagihan
 DocType: Asset,Double Declining Balance,Ganda Saldo Menurun
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +179,Closed order cannot be cancelled. Unclose to cancel.,Agar tertutup tidak dapat dibatalkan. Unclose untuk membatalkan.
-DocType: Patient Relation,Father,Ayah
-apps/erpnext/erpnext/controllers/accounts_controller.py +562,'Update Stock' cannot be checked for fixed asset sale,'Pembaruan Persediaan’ tidak dapat dipilih untuk penjualan aset tetap
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Agar tertutup tidak dapat dibatalkan. Unclose untuk membatalkan.
+DocType: Student Guardian,Father,Ayah
+apps/erpnext/erpnext/controllers/accounts_controller.py +606,'Update Stock' cannot be checked for fixed asset sale,'Pembaruan Persediaan’ tidak dapat dicentang untuk penjualan aset tetap
 DocType: Bank Reconciliation,Bank Reconciliation,Rekonsiliasi Bank
 DocType: Attendance,On Leave,Sedang cuti
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Dapatkan Update
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Akun {2} bukan milik Perusahaan {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +147,Material Request {0} is cancelled or stopped,Permintaan Material {0} dibatalkan atau dihentikan
-apps/erpnext/erpnext/config/hr.py +305,Leave Management,Manajemen Cuti
+apps/erpnext/erpnext/stock/doctype/item/item.js +366,Select at least one value from each of the attributes.,Pilih setidaknya satu nilai dari masing-masing atribut.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +156,Material Request {0} is cancelled or stopped,Permintaan Material {0} dibatalkan atau dihentikan
+apps/erpnext/erpnext/config/hr.py +310,Leave Management,Manajemen Cuti
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Group by Akun
 DocType: Sales Order,Fully Delivered,Sepenuhnya Terkirim
 DocType: Lead,Lower Income,Penghasilan rendah
 DocType: Restaurant Order Entry,Current Order,Pesanan saat ini
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +169,Source and target warehouse cannot be same for row {0},Sumber dan target gudang tidak bisa sama untuk baris {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +174,Source and target warehouse cannot be same for row {0},Sumber dan target gudang tidak bisa sama untuk baris {0}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Akun Perbedaan harus jenis rekening Aset / Kewajiban, karena Rekonsiliasi Persediaan adalah Entri Pembukaan"
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Dicairkan Jumlah tidak dapat lebih besar dari Jumlah Pinjaman {0}
-apps/erpnext/erpnext/utilities/user_progress.py +155,Go to Programs,Buka Program
+apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Buka Program
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Baris {0} # Jumlah alokasi {1} tidak boleh lebih besar dari jumlah yang tidak diklaim {2}
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Nomor Purchase Order yang diperlukan untuk Item {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +896,Production Order not created,Pesanan produksi tidak diciptakan
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +943,Production Order not created,Pesanan produksi tidak diciptakan
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date','Tanggal Mulai' harus sebelum 'Tanggal Akhir'
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},tidak dapat mengubah status sebagai mahasiswa {0} terkait dengan aplikasi mahasiswa {1}
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},tidak dapat mengubah status sebagai mahasiswa {0} terkait dengan aplikasi mahasiswa {1}
 DocType: Asset,Fully Depreciated,sepenuhnya disusutkan
 ,Stock Projected Qty,Proyeksi Jumlah Persediaan
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,Customer {0} does not belong to project {1},Pelanggan {0} tidak termasuk proyek {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +438,Customer {0} does not belong to project {1},Pelanggan {0} tidak termasuk proyek {1}
 DocType: Employee Attendance Tool,Marked Attendance HTML,Kehadiran ditandai HTML
 apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Penawaran adalah proposal, tawaran yang anda kirim kepada pelanggan"
 DocType: Sales Order,Customer's Purchase Order,Order Pembelian Pelanggan
 DocType: Consultation,Patient,Sabar
-apps/erpnext/erpnext/config/stock.py +117,Serial No and Batch,Serial dan Batch
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Cek kredit bypass di Sales Order
+DocType: Land Unit,Check if it is a hydroponic unit,Periksa apakah itu unit hidroponik
+apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,Serial dan Batch
 DocType: Warranty Claim,From Company,Dari Perusahaan
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Jumlah Skor Kriteria Penilaian perlu {0}.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Silakan mengatur Jumlah Penyusutan Dipesan
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Jumlah Skor Kriteria Penilaian perlu {0}.
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Silakan mengatur Jumlah Penyusutan Dipesan
 DocType: Supplier Scorecard Period,Calculations,Perhitungan
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Nilai atau Qty
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +425,Productions Orders cannot be raised for:,Produksi Pesanan tidak dapat diangkat untuk:
-apps/erpnext/erpnext/utilities/user_progress.py +126,Minute,Menit
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Harap tentukan Seri Penamaan untuk {0} melalui Setup&gt; Settings&gt; Naming Series
+DocType: Payment Terms Template,Payment Terms,Syarat pembayaran
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +426,Productions Orders cannot be raised for:,Produksi Pesanan tidak dapat diangkat untuk:
+apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Menit
 DocType: Purchase Invoice,Purchase Taxes and Charges,Pajak Pembelian dan Biaya
-apps/erpnext/erpnext/utilities/user_progress.py +100,Go to Suppliers,Pergi ke Pemasok
+DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
+apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Pergi ke Pemasok
 ,Qty to Receive,Kuantitas untuk diterima
 DocType: Leave Block List,Leave Block List Allowed,Cuti Block List Diizinkan
 DocType: Grading Scale Interval,Grading Scale Interval,Grading Scale Interval
@@ -3304,33 +3528,34 @@
 DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Discount (%) pada Price List Rate dengan Margin
 apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,semua Gudang
 DocType: Sales Partner,Retailer,Pengecer
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +112,Credit To account must be a Balance Sheet account,Kredit Untuk akun harus rekening Neraca
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Kredit Untuk akun harus rekening Neraca
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Semua Jenis Supplier
+DocType: Donor,Donor,Penyumbang
 DocType: Global Defaults,Disable In Words,Nonaktifkan Dalam Kata-kata
-apps/erpnext/erpnext/stock/doctype/item/item.py +51,Item Code is mandatory because Item is not automatically numbered,Item Code adalah wajib karena Item tidak secara otomatis nomor
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +97,Quotation {0} not of type {1},Penawaran {0} bukan jenis {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +49,Item Code is mandatory because Item is not automatically numbered,Item Code adalah wajib karena Item tidak secara otomatis nomor
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Penawaran {0} bukan jenis {1}
 DocType: Maintenance Schedule Item,Maintenance Schedule Item,Jadwal pemeliharaan Stok Barang
 DocType: Sales Order,%  Delivered,% Terkirim
-apps/erpnext/erpnext/schools/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,Harap atur ID Email untuk Siswa untuk mengirim Permintaan Pembayaran
+apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,Harap atur ID Email untuk Siswa untuk mengirim Permintaan Pembayaran
 DocType: Production Order,PRO-,PRO-
 DocType: Patient,Medical History,Riwayat kesehatan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Bank Akun Overdraft
 DocType: Patient,Patient ID,ID pasien
 DocType: Physician Schedule,Schedule Name,Nama Jadwal
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Membuat Slip Gaji
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +813,Add All Suppliers,Tambahkan Semua Pemasok
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Baris # {0}: Alokasi Jumlah tidak boleh lebih besar dari jumlah yang terutang.
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +838,Add All Suppliers,Tambahkan Semua Pemasok
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +83,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Baris # {0}: Alokasi Jumlah tidak boleh lebih besar dari jumlah yang terutang.
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Telusuri BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Pinjaman Aman
 DocType: Purchase Invoice,Edit Posting Date and Time,Mengedit Posting Tanggal dan Waktu
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Silahkan mengatur Penyusutan Akun terkait Aset Kategori {0} atau Perusahaan {1}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Silahkan mengatur Penyusutan Akun terkait Aset Kategori {0} atau Perusahaan {1}
 DocType: Lab Test Groups,Normal Range,Jarak normal
 DocType: Academic Term,Academic Year,Tahun akademik
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Jual Beli
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Saldo Pembukaan Ekuitas
 DocType: Lead,CRM,CRM
 DocType: Purchase Invoice,N,N
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +24,Reconciliation,Rekonsiliasi
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,sisa
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,sisa
 DocType: Appraisal,Appraisal,Penilaian
 DocType: Purchase Invoice,GST Details,Rincian GST
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},Email dikirim ke pemasok {0}
@@ -3339,22 +3564,23 @@
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Tanggal diulang
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Penandatangan yang Sah
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},Cuti approver harus menjadi salah satu {0}
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +66,Create Fees,Buat Biaya
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Buat Biaya
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Total Biaya Pembelian (Purchase Invoice via)
 DocType: Training Event,Start Time,Waktu Mulai
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +377,Select Quantity,Pilih Kuantitas
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +399,Select Quantity,Pilih Kuantitas
 DocType: Customs Tariff Number,Customs Tariff Number,Tarif Bea Nomor
 DocType: Patient Appointment,Patient Appointment,Penunjukan Pasien
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Menyetujui Peran tidak bisa sama dengan peran aturan yang Berlaku Untuk
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Berhenti berlangganan dari Email Ringkasan ini
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +803,Get Suppliers By,Dapatkan Pemasok Dengan
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{0} tidak ditemukan untuk Item {1}
-apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Courses,Pergi ke kursus
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +828,Get Suppliers By,Dapatkan Pemasok Dengan
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{0} tidak ditemukan untuk Barang {1}
+apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Pergi ke kursus
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Pesan Terkirim
-apps/erpnext/erpnext/accounts/doctype/account/account.py +101,Account with child nodes cannot be set as ledger,Akun dengan sub-akun tidak dapat ditetapkan sebagai buku
+apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Account with child nodes cannot be set as ledger,Akun dengan sub-akun tidak dapat ditetapkan sebagai buku
 DocType: C-Form,II,II
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Tingkat di mana mata uang Daftar Harga dikonversi ke mata uang dasar pelanggan
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Jumlah Bersih (Perusahaan Mata Uang)
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +229,Total advance amount cannot be greater than total sanctioned amount,Jumlah uang muka tidak boleh lebih besar dari jumlah sanksi
 DocType: Salary Slip,Hour Rate,Nilai per Jam
 DocType: Stock Settings,Item Naming By,Item Penamaan Dengan
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Lain Periode Pendaftaran penutupan {0} telah dibuat setelah {1}
@@ -3370,12 +3596,14 @@
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +155,Source and target warehouse must be different,Sumber dan gudang target harus berbeda
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Tidak diizinkan memperbarui transaksi persediaan lebih tua dari {0}
 DocType: Purchase Invoice Item,PR Detail,PR Detil
+DocType: Driving License Category,Class,Kelas
 DocType: Sales Order,Fully Billed,Sepenuhnya Ditagih
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Aturan pengiriman hanya berlaku untuk pembelian
 DocType: Vital Signs,BMI,BMI
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Cash In Hand
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +136,Delivery warehouse required for stock item {0},Gudang pengiriman diperlukan untuk persediaan barang {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Gudang pengiriman diperlukan untuk persediaan barang {0}
 DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Berat kotor paket. Berat + kemasan biasanya net berat bahan. (Untuk mencetak)
-apps/erpnext/erpnext/schools/doctype/course/course.js +3,Program,Program
+apps/erpnext/erpnext/education/doctype/course/course.js +3,Program,Program
 DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Pengguna dengan peran ini diperbolehkan untuk mengatur account beku dan membuat / memodifikasi entri akuntansi terhadap rekening beku
 DocType: Serial No,Is Cancelled,Apakah Dibatalkan
 DocType: Student Group,Group Based On,Grup Berdasarkan
@@ -3383,15 +3611,15 @@
 DocType: Healthcare Settings,Laboratory SMS Alerts,SMS Pemberitahuan Laboratorium
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Layanan Item, Jenis, frekuensi dan jumlah beban yang diperlukan"
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Bahkan jika ada beberapa Aturan Harga dengan prioritas tertinggi, kemudian mengikuti prioritas internal diterapkan:"
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +128,Do you really want to Submit all Salary Slip from {0} to {1},Apakah Anda benar-benar ingin Menyerahkan semua Slip Gaji dari {0} ke {1}
+DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kriteria Analisis Tanaman
 DocType: Cheque Print Template,Cheque Height,Cek Tinggi
 DocType: Supplier,Supplier Details,Rincian Supplier
 DocType: Setup Progress,Setup Progress,Setup Progress
 DocType: Expense Claim,Approval Status,Approval Status
 DocType: Hub Settings,Publish Items to Hub,Publikasikan Produk untuk Hub
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +43,From value must be less than to value in row {0},Dari nilai harus kurang dari nilai dalam baris {0}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +178,Wire Transfer,Transfer Kliring
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +132,Check all,Periksa Semua
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Dari nilai harus kurang dari nilai dalam baris {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,Transfer Kliring
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Periksa Semua
 DocType: Vehicle Log,Invoice Ref,faktur Ref
 DocType: Company,Default Income Account,Akun Pendapatan standar
 apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Kelompok Pelanggan / Pelanggan
@@ -3400,19 +3628,18 @@
 DocType: Lab Test Template,Change In Item,Ubah Item
 DocType: Payment Gateway Account,Default Payment Request Message,Standar Pesan Permintaan Pembayaran
 DocType: Item Group,Check this if you want to show in website,Periksa ini jika Anda ingin menunjukkan di website
-apps/erpnext/erpnext/config/accounts.py +142,Banking and Payments,Perbankan dan Pembayaran
+apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Perbankan dan Pembayaran
 ,Welcome to ERPNext,Selamat Datang di ERPNext
 apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Prospek menuju Penawaran
 DocType: Patient,A Negative,Negatif
 apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Tidak lebih untuk ditampilkan.
 DocType: Lead,From Customer,Dari Pelanggan
 apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Panggilan
-apps/erpnext/erpnext/utilities/user_progress.py +122,A Product,Produk
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +197,Batches,Batches
-DocType: Project,Total Costing Amount (via Time Logs),Jumlah Total Biaya (via Waktu Log)
-apps/erpnext/erpnext/schools/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Jadikan Jadwal Biaya
+apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Produk
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,Batches
+apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Jadikan Jadwal Biaya
 DocType: Purchase Order Item Supplied,Stock UOM,UOM Persediaan
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +230,Purchase Order {0} is not submitted,Order Pembelian {0} tidak terkirim
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Order Pembelian {0} tidak terkirim
 DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Rentang referensi normal untuk orang dewasa adalah 16-20 napas / menit (RCP 2012)
 DocType: Customs Tariff Number,Tariff Number,tarif Nomor
 DocType: Production Order Item,Available Qty at WIP Warehouse,Tersedia Qty di WIP Warehouse
@@ -3422,69 +3649,76 @@
 DocType: Notification Control,Quotation Message,Pesan Penawaran
 DocType: Employee Loan,Employee Loan Application,Karyawan Aplikasi Kredit
 DocType: Issue,Opening Date,Tanggal Pembukaan
-apps/erpnext/erpnext/schools/api.py +80,Attendance has been marked successfully.,Kehadiran telah ditandai berhasil.
+apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Kehadiran telah ditandai berhasil.
 DocType: Program Enrollment,Public Transport,Transportasi umum
+DocType: Soil Texture,Silt Composition (%),Komposisi Silt (%)
 DocType: Journal Entry,Remark,Komentar
 DocType: Healthcare Settings,Avoid Confirmation,Hindari Konfirmasi
 DocType: Purchase Receipt Item,Rate and Amount,Rate dan Jumlah
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +165,Account Type for {0} must be {1},Jenis Account untuk {0} harus {1}
 DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Akun pendapatan default yang akan digunakan jika tidak ditetapkan dalam Dokter untuk memesan biaya Konsultasi.
 apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Daun dan Liburan
-DocType: School Settings,Current Academic Term,Istilah Akademik Saat Ini
+DocType: Education Settings,Current Academic Term,Istilah Akademik Saat Ini
 DocType: Sales Order,Not Billed,Tidak Ditagih
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Kedua Gudang harus merupakan gudang dari Perusahaan yang sama
 apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Tidak ada kontak belum ditambahkan.
 DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Jumlah Nilai Voucher Landing Cost
 apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Tagihan diajukan oleh Pemasok.
 DocType: POS Profile,Write Off Account,Akun Write Off
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Debit Note Amt,Catatan Debet Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Debit Note Amt,Catatan Debet Amt
 apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Jumlah Diskon
 DocType: Purchase Invoice,Return Against Purchase Invoice,Retur Terhadap Faktur Pembelian
 DocType: Item,Warranty Period (in days),Masa Garansi (dalam hari)
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Hubungan dengan Guardian1
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Gagal menetapkan default
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Hubungan dengan Guardian1
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +797,Please select BOM against item {0},Silahkan pilih BOM terhadap item {0}
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Buat Faktur
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Kas Bersih dari Operasi
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Item 4
 DocType: Student Admission,Admission End Date,Pendaftaran Tanggal Akhir
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Sub-kontraktor
 DocType: Journal Entry Account,Journal Entry Account,Akun Jurnal Entri
-apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.js +3,Student Group,Kelompok mahasiswa
+apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Kelompok mahasiswa
 DocType: Shopping Cart Settings,Quotation Series,Seri Penawaran
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +56,"An item exists with same name ({0}), please change the item group name or rename the item","Sebuah item yang ada dengan nama yang sama ({0}), silakan mengubah nama kelompok Stok Barang atau mengubah nama item"
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2005,Please select customer,Silakan pilih pelanggan
+DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriteria Analisis Tanah
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2020,Please select customer,Silakan pilih pelanggan
 DocType: C-Form,I,saya
 DocType: Company,Asset Depreciation Cost Center,Asset Pusat Penyusutan Biaya
 DocType: Sales Order Item,Sales Order Date,Tanggal Nota Penjualan
 DocType: Sales Invoice Item,Delivered Qty,Qty Terkirim
 DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Jika dicentang, semua anak-anak dari setiap item produksi akan dimasukkan dalam Permintaan Material."
 DocType: Assessment Plan,Assessment Plan,Rencana penilaian
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Pelanggan {0} dibuat
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Pelanggan {0} dibuat
 DocType: Stock Settings,Limit Percent,batas Persen
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Saat ini tidak ada stok yang tersedia di gudang manapun
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Saat ini tidak ada persediaan di gudang manapun
 ,Payment Period Based On Invoice Date,Masa Pembayaran Berdasarkan Faktur Tanggal
 DocType: Sample Collection,No. of print,Jumlah cetak
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Hilang Kurs mata uang Tarif untuk {0}
 DocType: Assessment Plan,Examiner,Pemeriksa
-DocType: Patient Relation,Siblings,saudara
+DocType: Student,Siblings,saudara
 DocType: Journal Entry,Stock Entry,Entri Persediaan
 DocType: Payment Entry,Payment References,Referensi pembayaran
 DocType: C-Form,C-FORM-,C-bentuk-
 DocType: Vehicle,Insurance Details,Detail asuransi
 DocType: Account,Payable,Hutang
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Masukkan Periode Pembayaran
-apps/erpnext/erpnext/shopping_cart/cart.py +365,Debtors ({0}),Debitur ({0})
+apps/erpnext/erpnext/shopping_cart/cart.py +376,Debtors ({0}),Debitur ({0})
 DocType: Pricing Rule,Margin,Margin
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Pelanggan baru
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +75,Gross Profit %,Laba Kotor%
 DocType: Appraisal Goal,Weightage (%),Weightage (%)
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +489,Change POS Profile,Ubah Profil POS
 DocType: Bank Reconciliation Detail,Clearance Date,Izin Tanggal
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Laporan Penilaian
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Jumlah Pembelian kotor adalah wajib
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Laporan Penilaian
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Jumlah Pembelian kotor adalah wajib
 DocType: Lead,Address Desc,Deskripsi Alamat
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +101,Party is mandatory,Partai adalah wajib
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +102,Party is mandatory,Partai adalah wajib
 DocType: Journal Entry,JV-,JV-
+apps/erpnext/erpnext/controllers/accounts_controller.py +687,Rows with duplicate due dates in other rows were found: {list},Baris dengan tanggal jatuh tempo duplikat pada baris lainnya ditemukan: {list}
 DocType: Topic,Topic Name,topik Nama
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,"Setidaknya salah satu, Jual atau Beli harus dipilih"
-apps/erpnext/erpnext/public/js/setup_wizard.js +33,Select the nature of your business.,Pilih jenis bisnis anda.
+apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Pilih jenis bisnis anda.
 DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
 <br>
 Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
@@ -3494,19 +3728,21 @@
 Grouped for test templates which are a group of other test templates.
 <br>
 No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Single untuk hasil yang hanya memerlukan satu input saja, hasil UOM dan nilai normal <br> Senyawa untuk hasil yang membutuhkan banyak field masukan dengan nama acara yang sesuai, hasil UOM dan nilai normal <br> Deskriptif untuk tes yang memiliki beberapa komponen hasil dan bidang entri hasil yang sesuai. <br> Dikelompokkan untuk template uji yang merupakan kelompok dari template uji lainnya. <br> Tidak ada hasil untuk tes tanpa hasil. Juga, tidak ada Lab Test yang dibuat. misalnya. Sub Tes untuk hasil yang dikelompokkan."
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +73,Row #{0}: Duplicate entry in References {1} {2},Baris # {0}: Entri duplikat di Referensi {1} {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +75,Row #{0}: Duplicate entry in References {1} {2},Baris # {0}: Entri duplikat di Referensi {1} {2}
 apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Dimana operasi manufaktur dilakukan.
 DocType: Asset Movement,Source Warehouse,Sumber Gudang
 DocType: Installation Note,Installation Date,Instalasi Tanggal
-apps/erpnext/erpnext/controllers/accounts_controller.py +541,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Aset {1} bukan milik perusahaan {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +585,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Aset {1} bukan milik perusahaan {2}
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Faktur Penjualan {0} dibuat
 DocType: Employee,Confirmation Date,Konfirmasi Tanggal
 DocType: C-Form,Total Invoiced Amount,Jumlah Total Tagihan
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,Min Qty tidak dapat lebih besar dari Max Qty
+DocType: Soil Texture,Silty Clay,Silty Clay
 DocType: Account,Accumulated Depreciation,Akumulasi penyusutan
 DocType: Supplier Scorecard Scoring Standing,Standing Name,Nama berdiri
 DocType: Stock Entry,Customer or Supplier Details,Rincian Pelanggan atau Pemasok
 DocType: Employee Loan Application,Required by Date,Dibutuhkan oleh Tanggal
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +222,Closing Balance (Dr - Cr),Saldo Penutupan (Dr - Cr)
 DocType: Lead,Lead Owner,Pemilik Prospek
 DocType: Bin,Requested Quantity,diminta Kuantitas
 DocType: Patient,Marital Status,Status Perkawinan
@@ -3516,33 +3752,36 @@
 DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Pay Gross - Jumlah Pengurangan - Pelunasan Pinjaman
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +26,Current BOM and New BOM can not be same,BOM Lancar dan New BOM tidak bisa sama
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +45,Salary Slip ID,Slip Gaji ID
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date Of Retirement must be greater than Date of Joining,Tanggal Of Pensiun harus lebih besar dari Tanggal Bergabung
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +52,There were errors while scheduling course on :,Ada kesalahan saat penjadwalan kursus pada:
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,Tanggal Of Pensiun harus lebih besar dari Tanggal Bergabung
+apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Beberapa varian
 DocType: Sales Invoice,Against Income Account,Terhadap Akun Pendapatan
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Terkirim
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +95,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Item {0}: qty Memerintahkan {1} tidak bisa kurang dari qty minimum order {2} (didefinisikan dalam Butir).
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +96,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Item {0}: qty Memerintahkan {1} tidak bisa kurang dari qty minimum order {2} (didefinisikan dalam Butir).
 DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Bulanan Persentase Distribusi
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +90,Please login as another user.,Silahkan login sebagai pengguna lain.
 DocType: Territory,Territory Targets,Target Wilayah
+DocType: Soil Analysis,Ca/Mg,Ca / Mg
 DocType: Delivery Note,Transporter Info,Info Transporter
-apps/erpnext/erpnext/accounts/utils.py +497,Please set default {0} in Company {1},Silahkan mengatur default {0} di Perusahaan {1}
+apps/erpnext/erpnext/accounts/utils.py +499,Please set default {0} in Company {1},Silahkan mengatur default {0} di Perusahaan {1}
 DocType: Cheque Print Template,Starting position from top edge,Mulai posisi dari tepi atas
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +31,Same supplier has been entered multiple times,pemasok yang sama telah dimasukkan beberapa kali
 apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Laba Kotor / Rugi
 DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Purchase Order Stok Barang Disediakan
-apps/erpnext/erpnext/public/js/setup_wizard.js +90,Company Name cannot be Company,Nama perusahaan tidak dapat perusahaan
+apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Nama perusahaan tidak dapat perusahaan
 apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Surat Kepala untuk mencetak template.
 apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Judul untuk mencetak template misalnya Proforma Invoice.
 DocType: Program Enrollment,Walking,Berjalan
 DocType: Student Guardian,Student Guardian,Wali murid
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +201,Valuation type charges can not marked as Inclusive,Jenis penilaian biaya tidak dapat ditandai sebagai Inklusif
+DocType: Member,Member Name,Nama anggota
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Jenis penilaian biaya tidak dapat ditandai sebagai Inklusif
 DocType: POS Profile,Update Stock,Perbarui Persediaan
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,dalam berlangganan
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,UOM berbeda akan menyebabkan kesalahan Berat Bersih (Total). Pastikan Berat Bersih untuk setiap barang memakai UOM yang sama.
+DocType: Membership,Payment Details,Rincian Pembayaran
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,Tingkat BOM
 DocType: Asset,Journal Entry for Scrap,Jurnal masuk untuk Scrap
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Silakan tarik item dari Pengiriman Note
-apps/erpnext/erpnext/accounts/utils.py +467,Journal Entries {0} are un-linked,Entri jurnal {0} un-linked
+apps/erpnext/erpnext/accounts/utils.py +469,Journal Entries {0} are un-linked,Entri jurnal {0} un-linked
 apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Catatan dari semua komunikasi email, telepon, chatting, kunjungan, dll"
 DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Penilai Scorecard Penilai Berdiri
 DocType: Manufacturer,Manufacturers used in Items,Produsen yang digunakan dalam Produk
@@ -3552,9 +3791,10 @@
 DocType: Buying Settings,Purchase Order Required,Order Pembelian Diperlukan
 ,Item-wise Sales History,Item-wise Penjualan Sejarah
 DocType: Expense Claim,Total Sanctioned Amount,Jumlah Total Disahkan
+DocType: Land Unit,Land Unit,Unit tanah
 ,Purchase Analytics,Pembelian Analytics
 DocType: Sales Invoice Item,Delivery Note Item,Pengiriman Stok Barang Note
-DocType: Expense Claim,Task,Tugas
+DocType: Asset Maintenance Log,Task,Tugas
 DocType: Purchase Taxes and Charges,Reference Row #,Referensi Row #
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Nomor batch adalah wajib untuk Persediaan {0}
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Ini adalah orang penjualan akar dan tidak dapat diedit.
@@ -3563,8 +3803,8 @@
 apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Tingkat: {0}
 DocType: Company,Exchange Gain / Loss Account,Efek Gain / Loss Akun
 apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Karyawan dan Kehadiran
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +78,Purpose must be one of {0},Tujuan harus menjadi salah satu {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,Fill the form and save it,Isi formulir dan menyimpannya
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Purpose must be one of {0},Tujuan harus menjadi salah satu {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +116,Fill the form and save it,Isi formulir dan menyimpannya
 DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,Unduh laporan yang berisi semua bahan baku dengan status persediaan terbarunya
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum Komunitas
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Jumlah persediaan aktual
@@ -3577,7 +3817,7 @@
 DocType: Purchase Order,Get Items from Open Material Requests,Dapatkan Produk dari Permintaan Buka Material
 DocType: Lab Test Template,Standard Selling Rate,Standard Jual Tingkat
 DocType: Account,Rate at which this tax is applied,Tingkat di mana pajak ini diterapkan
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +65,Reorder Qty,Susun ulang Qty
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +75,Reorder Qty,Susun ulang Qty
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Job Openings saat
 DocType: Company,Stock Adjustment Account,Penyesuaian Akun Persediaan
 apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Mencoret
@@ -3588,36 +3828,41 @@
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +49,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,"Diantrikan untuk memperbaharui harga terakhir di ""Bill of Material"". Akan memakan waktu beberapa menit."
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Nama Akun baru. Catatan: Jangan membuat akun untuk Pelanggan dan Pemasok
 apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Negara bijaksana Alamat bawaan Template
+DocType: Water Analysis,Appearance,Penampilan
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Rata-rata Tarif Daftar Harga Beli
 DocType: Sales Order Item,Supplier delivers to Customer,Pemasok mengirim ke Pelanggan
-apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (#Form/Item/{0}) tidak tersedia
+apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Informasi anggota
+apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (#Formulir/Barang/{0}) tidak tersedia
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Pemeliharaan Aset
 ,Sales Payment Summary,Ringkasan Pembayaran Penjualan
 DocType: Restaurant,Restaurant,Restoran
-apps/erpnext/erpnext/accounts/party.py +322,Due / Reference Date cannot be after {0},Karena / Referensi Tanggal tidak boleh setelah {0}
+apps/erpnext/erpnext/accounts/party.py +323,Due / Reference Date cannot be after {0},Karena / Referensi Tanggal tidak boleh setelah {0}
 apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Data Impor dan Ekspor
 DocType: Patient,Account Details,Rincian Account
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +76,No students Found,Tidak ada siswa Ditemukan
+DocType: Crop,Materials Required,Bahan yang dibutuhkan
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Tidak ada siswa Ditemukan
 DocType: Medical Department,Medical Department,Departemen Kesehatan
 DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kriteria penilaian scorecard pemasok
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Faktur Posting Tanggal
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Menjual
-DocType: Sales Invoice,Rounded Total,Rounded Jumlah
+DocType: Purchase Invoice,Rounded Total,Rounded Jumlah
 DocType: Product Bundle,List items that form the package.,Daftar item yang membentuk paket.
 apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Persentase Alokasi harus sama dengan 100%
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +567,Please select Posting Date before selecting Party,Silakan pilih Posting Tanggal sebelum memilih Partai
+DocType: Crop Cycle,Linked Land Unit,Linked Land Unit
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Silakan pilih Posting Tanggal sebelum memilih Partai
 DocType: Program Enrollment,School House,Asrama Sekolah
 DocType: Serial No,Out of AMC,Dari AMC
-apps/erpnext/erpnext/public/js/utils.js +263,Please select Quotations,Silakan pilih Kutipan
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Jumlah Penyusutan Memesan tidak dapat lebih besar dari total jumlah Penyusutan
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Jumlah Penyusutan Memesan tidak dapat lebih besar dari total jumlah Penyusutan
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Membuat Maintenance Visit
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +170,Please contact to the user who have Sales Master Manager {0} role,Silahkan hubungi untuk pengguna yang memiliki penjualan Guru Manajer {0} peran
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +198,Please contact to the user who have Sales Master Manager {0} role,Silahkan hubungi untuk pengguna yang memiliki penjualan Guru Manajer {0} peran
 DocType: Company,Default Cash Account,Standar Rekening Kas
 apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Perusahaan (bukan Pelanggan atau Pemasok) Utama.
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Hal ini didasarkan pada kehadiran mahasiswa ini
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Tidak ada siswa
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Hal ini didasarkan pada kehadiran mahasiswa ini
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Tidak ada siswa
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +171,Add more items or open full form,Menambahkan item atau buka formulir selengkapnya
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +206,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Catatan pengiriman {0} harus dibatalkan sebelum membatalkan Sales Order ini
-apps/erpnext/erpnext/utilities/user_progress.py +238,Go to Users,Buka Pengguna
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +82,Paid amount + Write Off Amount can not be greater than Grand Total,Jumlah yang dibayarkan + Write Off Jumlah tidak bisa lebih besar dari Grand Total
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Catatan pengiriman {0} harus dibatalkan sebelum membatalkan Sales Order ini
+apps/erpnext/erpnext/utilities/user_progress.py +256,Go to Users,Buka Pengguna
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Jumlah yang dibayarkan + Write Off Jumlah tidak bisa lebih besar dari Grand Total
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} tidak Nomor Batch berlaku untuk Stok Barang {1}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Note: There is not enough leave balance for Leave Type {0},Catatan: Tidak ada saldo cuti cukup bagi Leave Type {0}
 apps/erpnext/erpnext/regional/india/utils.py +15,Invalid GSTIN or Enter NA for Unregistered,GSTIN tidak valid atau Enter NA untuk tidak terdaftar
@@ -3635,31 +3880,35 @@
 DocType: Hub Settings,Publish Availability,Publikasikan Ketersediaan
 DocType: Company,Create Chart Of Accounts Based On,Buat Bagan Of Account Berbasis Pada
 apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Tidak dapat mengubahnya menjadi non-grup. Tugas Anak ada.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date of Birth cannot be greater than today.,Tanggal Lahir tidak dapat lebih besar dari saat ini.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,Tanggal Lahir tidak dapat lebih besar dari saat ini.
 ,Stock Ageing,Usia Persediaan
-apps/erpnext/erpnext/schools/doctype/student/student.py +38,Student {0} exist against student applicant {1},Mahasiswa {0} ada terhadap pemohon mahasiswa {1}
+apps/erpnext/erpnext/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Mahasiswa {0} ada terhadap pemohon mahasiswa {1}
 DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Penyesuaian Pembulatan (Mata Uang Perusahaan)
 apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Timesheet
-apps/erpnext/erpnext/controllers/accounts_controller.py +233,{0} '{1}' is disabled,{0} '{1}' dinonaktifkan
+DocType: Volunteer,Afternoon,Sore
+apps/erpnext/erpnext/controllers/accounts_controller.py +256,{0} '{1}' is disabled,{0} '{1}' dinonaktifkan
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Ditetapkan sebagai Terbuka
 DocType: Cheque Print Template,Scanned Cheque,Cek Terpindai
 DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Kirim email otomatis ke Kontak untuk Pengiriman transaksi.
 DocType: Timesheet,Total Billable Amount,Jumlah Total Ditagih
+DocType: Customer,Credit Limit and Payment Terms,Batas Kredit dan Persyaratan Pembayaran
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Butir 3
 apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Pesanan masuk
 DocType: Purchase Order,Customer Contact Email,Email Kontak Pelanggan
 DocType: Warranty Claim,Item and Warranty Details,Item dan Garansi Detail
+DocType: Chapter,Chapter Members,Anggota Bab
 DocType: Sales Team,Contribution (%),Kontribusi (%)
-apps/erpnext/erpnext/controllers/accounts_controller.py +75,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Catatan: Entry Pembayaran tidak akan dibuat karena 'Cash atau Rekening Bank tidak ditentukan
-apps/erpnext/erpnext/projects/doctype/project/project.py +65,Project {0} already exists,Project {0} sudah ada
+apps/erpnext/erpnext/controllers/accounts_controller.py +100,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Catatan: Entry Pembayaran tidak akan dibuat karena 'Cash atau Rekening Bank tidak ditentukan
+apps/erpnext/erpnext/projects/doctype/project/project.py +67,Project {0} already exists,Project {0} sudah ada
 DocType: Medical Department,Nursing User,Pengguna perawatan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +227,Responsibilities,Tanggung Jawab
+DocType: Plant Analysis,Plant Analysis Criterias,Kriteria Analisis Tanaman
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Responsibilities,Tanggung Jawab
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Masa berlaku dari kutipan ini telah berakhir.
 DocType: Expense Claim Account,Expense Claim Account,Akun Beban Klaim
 DocType: Accounts Settings,Allow Stale Exchange Rates,Biarkan nilai tukar basi
 DocType: Sales Person,Sales Person Name,Penjualan Person Nama
 apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Entrikan minimal 1 faktur dalam tabel
-apps/erpnext/erpnext/utilities/user_progress.py +226,Add Users,Tambah Pengguna
+apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Tambah Pengguna
 DocType: POS Item Group,Item Group,Item Grup
 DocType: Item,Safety Stock,Persediaan Aman
 DocType: Healthcare Settings,Healthcare Settings,Pengaturan Kesehatan
@@ -3667,74 +3916,78 @@
 DocType: Stock Reconciliation Item,Before reconciliation,Sebelum rekonsiliasi
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Untuk {0}
 DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Pajak dan Biaya Ditambahkan (Perusahaan Mata Uang)
-apps/erpnext/erpnext/stock/doctype/item/item.py +445,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Item Pajak Row {0} harus memiliki akun Pajak jenis atau Penghasilan atau Beban atau Dibebankan
+apps/erpnext/erpnext/stock/doctype/item/item.py +461,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Item Pajak Row {0} harus memiliki akun Pajak jenis atau Penghasilan atau Beban atau Dibebankan
 DocType: Sales Order,Partly Billed,Sebagian Ditagih
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Item {0} harus menjadi Asset barang Tetap
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Item {0} harus menjadi Asset barang Tetap
+apps/erpnext/erpnext/stock/doctype/item/item.js +341,Make Variants,Buatlah Varian
 DocType: Item,Default BOM,BOM Standar
+DocType: Project,Total Billed Amount (via Sales Invoices),Total Jumlah Bills (via Faktur Penjualan)
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Jumlah Catatan Debet
 apps/erpnext/erpnext/setup/doctype/company/company.js +60,Please re-type company name to confirm,Mohon tipe nama perusahaan untuk mengkonfirmasi
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +79,Total Outstanding Amt,Jumlah Posisi Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Total Outstanding Amt,Jumlah Posisi Amt
 DocType: Journal Entry,Printing Settings,Pengaturan pencetakan
+DocType: Employee Advance,Advance Account,Uang muka
 DocType: Sales Invoice,Include Payment (POS),Sertakan Pembayaran (POS)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Jumlah Debit harus sama dengan total kredit. Perbedaannya adalah {0}
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +11,Automotive,Otomotif
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +290,Total Debit must be equal to Total Credit. The difference is {0},Jumlah Debit harus sama dengan total kredit. Perbedaannya adalah {0}
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Otomotif
 DocType: Vehicle,Insurance Company,Perusahaan asuransi
 DocType: Asset Category Account,Fixed Asset Account,Akun Aset Tetap
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Variable,Variabel
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,Variabel
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Dari Delivery Note
+DocType: Chapter,Members,Anggota
 DocType: Student,Student Email Address,Alamat Email Siswa
 DocType: Item,Hub Warehouse,Gudang Hub
-DocType: Physician Schedule Time Slot,From Time,Dari Waktu
+DocType: Assessment Plan,From Time,Dari Waktu
 apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Persediaan:
 DocType: Notification Control,Custom Message,Custom Pesan
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +33,Investment Banking,Perbankan Investasi
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +78,Cash or Bank Account is mandatory for making payment entry,Kas atau Rekening Bank wajib untuk membuat entri pembayaran
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Alamat siswa
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Perbankan Investasi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Kas atau Rekening Bank wajib untuk membuat entri pembayaran
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Alamat siswa
 DocType: Purchase Invoice,Price List Exchange Rate,Daftar Harga Tukar
+apps/erpnext/erpnext/accounts/doctype/account/account.py +253,Account Number {0} already used in account {1},Nomor Akun {0} sudah digunakan di akun {1}
 DocType: POS Profile,POS Profile Name,Nama Profil POS
 DocType: Purchase Invoice Item,Rate,Harga
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +100,Intern,Menginternir
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1569,Address Name,Nama alamat
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Menginternir
+DocType: Delivery Stop,Address Name,Nama alamat
 DocType: Stock Entry,From BOM,Dari BOM
 DocType: Assessment Code,Assessment Code,Kode penilaian
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +69,Basic,Dasar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Dasar
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Transaksi persediaan sebelum {0} dibekukan
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',Silahkan klik 'Menghasilkan Jadwal'
-apps/erpnext/erpnext/config/stock.py +195,"e.g. Kg, Unit, Nos, m","misalnya Kg, Unit, Nos, m"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,Referensi ada adalah wajib jika Anda memasukkan Referensi Tanggal
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,Reference No is mandatory if you entered Reference Date,Referensi ada adalah wajib jika Anda memasukkan Referensi Tanggal
 DocType: Bank Reconciliation Detail,Payment Document,Dokumen pembayaran
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Kesalahan dalam mengevaluasi rumus kriteria
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +110,Date of Joining must be greater than Date of Birth,Tanggal Bergabung harus lebih besar dari Tanggal Lahir
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,Tanggal Bergabung harus lebih besar dari Tanggal Lahir
 DocType: Salary Slip,Salary Structure,Struktur Gaji
 DocType: Account,Bank,Bank
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +9,Airline,Maskapai Penerbangan
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +827,Issue Material,Isu Material
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Maskapai Penerbangan
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +852,Issue Material,Isu Material
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Terjadi kesalahan saat membuat berulang
 DocType: Material Request Item,For Warehouse,Untuk Gudang
 DocType: Employee,Offer Date,Penawaran Tanggal
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Penawaran
-apps/erpnext/erpnext/accounts/page/pos/pos.js +711,You are in offline mode. You will not be able to reload until you have network.,Anda berada dalam mode offline. Anda tidak akan dapat memuat sampai Anda memiliki jaringan.
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Tidak Grup Pelajar dibuat.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +726,You are in offline mode. You will not be able to reload until you have network.,Anda berada dalam mode offline. Anda tidak akan dapat memuat sampai Anda memiliki jaringan.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Tidak Grup Pelajar dibuat.
 DocType: Purchase Invoice Item,Serial No,Serial ada
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Bulanan Pembayaran Jumlah tidak dapat lebih besar dari Jumlah Pinjaman
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Cukup masukkan Maintaince Detail terlebih dahulu
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +55,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Baris # {0}: Tanggal Pengiriman yang Diharapkan tidak boleh sebelum Tanggal Pemesanan Pembelian
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Baris # {0}: Tanggal Pengiriman yang Diharapkan tidak boleh sebelum Tanggal Pemesanan Pembelian
 DocType: Purchase Invoice,Print Language,cetak Bahasa
 DocType: Salary Slip,Total Working Hours,Jumlah Jam Kerja
 DocType: Subscription,Next Schedule Date,Jadwal Jadwal Berikutnya
 DocType: Stock Entry,Including items for sub assemblies,Termasuk item untuk sub rakitan
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1928,Enter value must be positive,Masukkan nilai harus positif
+DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Rekening Pembukaan Sementara
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1943,Enter value must be positive,Masukkan nilai harus positif
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,Semua Wilayah
 DocType: Purchase Invoice,Items,Items
-apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +26,Student is already enrolled.,Mahasiswa sudah terdaftar.
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +28,Student is already enrolled.,Mahasiswa sudah terdaftar.
 DocType: Fiscal Year,Year Name,Nama Tahun
-DocType: Process Payroll,Process Payroll,Proses Payroll
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Ada lebih dari hari kerja libur bulan ini.
 DocType: Product Bundle Item,Product Bundle Item,Barang Bundel Produk
 DocType: Sales Partner,Sales Partner Name,Penjualan Mitra Nama
-apps/erpnext/erpnext/hooks.py +132,Request for Quotations,Permintaan Kutipan
+apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Permintaan Kutipan
 DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimum Faktur Jumlah
-apps/erpnext/erpnext/healthcare/setup.py +209,Haematology,Hematologi
+apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Hematologi
 DocType: Normal Test Items,Normal Test Items,Item Uji Normal
 DocType: Student Language,Student Language,Bahasa siswa
 apps/erpnext/erpnext/config/selling.py +23,Customers,Pelanggan
@@ -3744,11 +3997,12 @@
 DocType: Asset,Partially Depreciated,sebagian disusutkan
 DocType: Issue,Opening Time,Membuka Waktu
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Dari dan Untuk tanggal yang Anda inginkan
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +46,Securities & Commodity Exchanges,Efek & Bursa Komoditi
-apps/erpnext/erpnext/stock/doctype/item/item.py +675,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Standar Satuan Ukur untuk Variant &#39;{0}&#39; harus sama seperti di Template &#39;{1}&#39;
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Efek & Bursa Komoditi
+apps/erpnext/erpnext/stock/doctype/item/item.py +661,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Standar Satuan Ukur untuk Variant &#39;{0}&#39; harus sama seperti di Template &#39;{1}&#39;
 DocType: Shipping Rule,Calculate Based On,Hitung Berbasis On
 DocType: Delivery Note Item,From Warehouse,Dari Gudang
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +897,No Items with Bill of Materials to Manufacture,Tidak ada Item dengan Bill of Material untuk Industri
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Tidak ada karyawan untuk kriteria tersebut
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +944,No Items with Bill of Materials to Manufacture,Tidak ada Item dengan Bill of Material untuk Industri
 DocType: Restaurant,Default Customer,Pelanggan default
 DocType: Assessment Plan,Supervisor Name,Nama pengawas
 DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Jangan mengkonfirmasi jika janji dibuat untuk hari yang sama
@@ -3758,40 +4012,41 @@
 DocType: Tax Rule,Shipping City,Pengiriman Kota
 DocType: Notification Control,Customize the Notification,Sesuaikan Pemberitahuan
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Arus Kas dari Operasi
-DocType: Sales Invoice,Shipping Rule,Aturan Pengiriman
+DocType: Purchase Invoice,Shipping Rule,Aturan Pengiriman
 DocType: Patient Relation,Spouse,Pasangan
 DocType: Lab Test Groups,Add Test,Tambahkan Test
 DocType: Manufacturer,Limited to 12 characters,Terbatas untuk 12 karakter
 DocType: Journal Entry,Print Heading,Cetak Pos
+apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Pengiriman Trip service tours ke pelanggan.
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Jumlah tidak boleh nol
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,'Hari Sejak Pemesanan terakhir' harus lebih besar dari atau sama dengan nol
-DocType: Process Payroll,Payroll Frequency,Payroll Frekuensi
+apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,'Hari Sejak Pesanan Terakhir' harus lebih besar dari atau sama dengan nol
+DocType: Plant Analysis Criteria,Maximum Permissible Value,Nilai Maksimum yang Diijinkan
+DocType: Journal Entry Account,Employee Advance,Uang muka karyawan
+DocType: Payroll Entry,Payroll Frequency,Payroll Frekuensi
 DocType: Lab Test Template,Sensitivity,Kepekaan
-DocType: Asset,Amended From,Diubah Dari
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +58,Raw Material,Bahan Baku
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +62,Raw Material,Bahan Baku
 DocType: Leave Application,Follow via Email,Ikuti via Email
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Tanaman dan Mesin
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Jumlah pajak Setelah Diskon Jumlah
 DocType: Daily Work Summary Settings,Daily Work Summary Settings,Pengaturan Kerja Ringkasan Harian
 DocType: Payment Entry,Internal Transfer,internal transfer
-apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Child account exists for this account. You can not delete this account.,Akun anak ada untuk akun ini. Anda tidak dapat menghapus akun ini.
+DocType: Asset Maintenance,Maintenance Tasks,Tugas pemeliharaan
 apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Entah sasaran qty atau jumlah target adalah wajib
-apps/erpnext/erpnext/stock/get_item_details.py +536,No default BOM exists for Item {0},Tidak ada standar BOM ada untuk Item {0}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +359,Please select Posting Date first,Silakan pilih Posting Tanggal terlebih dahulu
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +367,Please select Posting Date first,Silakan pilih Posting Tanggal terlebih dahulu
 apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Tanggal Pembukaan harus sebelum Tanggal Penutupan
 DocType: Leave Control Panel,Carry Forward,Carry Teruskan
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Biaya Center dengan transaksi yang ada tidak dapat dikonversi ke buku
 DocType: Department,Days for which Holidays are blocked for this department.,Hari yang Holidays diblokir untuk departemen ini.
+DocType: Crop Cycle,Detected Disease,Penyakit Terdeteksi
 ,Produced,Diproduksi
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +118,Created Salary Slips,Dibuat Slips Gaji
 DocType: Item,Item Code for Suppliers,Item Code untuk Supplier
 DocType: Issue,Raised By (Email),Dimunculkan Oleh (Email)
 DocType: Training Event,Trainer Name,Nama pelatih
 DocType: Mode of Payment,General,Umum
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Komunikasi terakhir
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +355,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Tidak bisa mengurangi ketika kategori adalah untuk 'Penilaian' atau 'Penilaian dan Total'
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Tidak bisa mengurangi ketika kategori adalah untuk 'Penilaian' atau 'Penilaian dan Total'
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Nomor Seri Diperlukan untuk Barang Bernomor Seri {0}
-apps/erpnext/erpnext/config/accounts.py +152,Match Payments with Invoices,Pembayaran pertandingan dengan Faktur
+apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Pembayaran pertandingan dengan Faktur
 DocType: Journal Entry,Bank Entry,Entri Bank
 DocType: Authorization Rule,Applicable To (Designation),Berlaku Untuk (Penunjukan)
 ,Profitability Analysis,Analisis profitabilitas
@@ -3801,17 +4056,19 @@
 apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Tambahkan ke Keranjang Belanja
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Kelompok Dengan
 DocType: Guardian,Interests,minat
-apps/erpnext/erpnext/config/accounts.py +306,Enable / disable currencies.,Mengaktifkan / menonaktifkan mata uang.
+apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Mengaktifkan / menonaktifkan mata uang.
 DocType: Production Planning Tool,Get Material Request,Dapatkan Material Permintaan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Beban pos
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Total (Amt)
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,Hiburan & Kenyamanan
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Hiburan & Kenyamanan
+,Item Variant Details,Rincian Item Variant
 DocType: Quality Inspection,Item Serial No,Item Serial No
 apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Buat Rekaman Karyawan
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Total Hadir
-apps/erpnext/erpnext/config/accounts.py +113,Accounting Statements,Laporan akuntansi
+apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,Laporan akuntansi
 DocType: Drug Prescription,Hour,Jam
 DocType: Restaurant Order Entry,Last Sales Invoice,Faktur penjualan terakhir
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +799,Please select Qty against item {0},Silakan pilih Qty terhadap item {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,No. Seri baru tidak dapat memiliki Gudang. Gudang harus diatur oleh Entri Persediaan atau Nota Pembelian
 DocType: Lead,Lead Type,Jenis Prospek
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Anda tidak berwenang untuk menyetujui cuti di Blok Tanggal
@@ -3823,6 +4080,7 @@
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,tidak diketahui
 DocType: Shipping Rule,Shipping Rule Conditions,Aturan Pengiriman Kondisi
 DocType: Purchase Invoice,Export Type,Jenis ekspor
+DocType: Salary Slip Loan,Salary Slip Loan,Pinjaman Saldo Gaji
 DocType: BOM Update Tool,The new BOM after replacement,The BOM baru setelah penggantian
 ,Point of Sale,Point of Sale
 DocType: Payment Entry,Received Amount,menerima Jumlah
@@ -3830,77 +4088,86 @@
 DocType: GST Settings,GSTIN Email Sent On,Email GSTIN Terkirim Pada
 DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop oleh Guardian
 DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Buat kuantitas penuh, mengabaikan kuantitas sudah pada pesanan"
+DocType: Crop,Planting UOM,Menanam UOM
 DocType: Account,Tax,PPN
-apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,tidak Ditandai
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,tidak Ditandai
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Membuka Faktur Ringkasan
+DocType: Education Settings,Education Manager,Manajer Pendidikan
 DocType: Production Planning Tool,Production Planning Tool,Alat Perencanaan Produksi
+DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Panjang minimum antara masing-masing pabrik di lapangan untuk pertumbuhan optimum
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Item Batched {0} tidak dapat diperbarui menggunakan Rekonsiliasi Persdediaan, gunakan Entri Persediaan"
 DocType: Quality Inspection,Report Date,Tanggal Laporan
 DocType: Student,Middle Name,Nama tengah
 DocType: C-Form,Invoices,Faktur
+DocType: Water Analysis,Type of Sample,Jenis Sampel
 DocType: Batch,Source Document Name,Nama dokumen sumber
 DocType: Job Opening,Job Title,Jabatan
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} menunjukkan bahwa {1} tidak akan memberikan kutipan, namun semua item \ telah dikutip. Memperbarui status kutipan RFQ."
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +971,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Sampel Maksimum - {0} telah disimpan untuk Batch {1} dan Item {2} di Batch {3}.
 DocType: Manufacturing Settings,Update BOM Cost Automatically,Update BOM Cost secara otomatis
 DocType: Lab Test,Test Name,Nama uji
 apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Buat Pengguna
-apps/erpnext/erpnext/utilities/user_progress.py +126,Gram,Gram
+apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,Gram
 DocType: Supplier Scorecard,Per Month,Per bulan
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +394,Quantity to Manufacture must be greater than 0.,Kuantitas untuk Produksi harus lebih besar dari 0.
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,Kuantitas untuk Produksi harus lebih besar dari 0.
 apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Kunjungi laporan untuk panggilan pemeliharaan.
 DocType: Stock Entry,Update Rate and Availability,Update Rate dan Ketersediaan
 DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,Persentase Anda diijinkan untuk menerima atau memberikan lebih terhadap kuantitas memerintahkan. Misalnya: Jika Anda telah memesan 100 unit. dan Tunjangan Anda adalah 10% maka Anda diperbolehkan untuk menerima 110 unit.
 DocType: POS Customer Group,Customer Group,Kelompok Pelanggan
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +113,New Batch ID (Optional),ID Batch Baru (Opsional)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +198,Expense account is mandatory for item {0},Rekening pengeluaran adalah wajib untuk item {0}
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +120,New Batch ID (Optional),ID Batch Baru (Opsional)
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Rekening pengeluaran adalah wajib untuk item {0}
 DocType: BOM,Website Description,Website Description
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Perubahan Bersih Ekuitas
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +196,Newest,Terbaru
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Batalkan Purchase Invoice {0} pertama
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Batalkan Purchase Invoice {0} pertama
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","Alamat Email harus unik, sudah ada untuk {0}"
 DocType: Serial No,AMC Expiry Date,Tanggal Kadaluarsa AMC
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +840,Receipt,Penerimaan
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Receipt,Penerimaan
 ,Sales Register,Daftar Penjualan
 DocType: Daily Work Summary Settings Company,Send Emails At,Kirim Email pada
 DocType: Quotation,Quotation Lost Reason,Alasan Kalah Penawaran
-apps/erpnext/erpnext/public/js/setup_wizard.js +19,Select your Domain,Pilih Domain Anda
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +367,Transaction reference no {0} dated {1},referensi transaksi tidak ada {0} tertanggal {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,Transaction reference no {0} dated {1},referensi transaksi tidak ada {0} tertanggal {1}
 apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Tidak ada yang mengedit.
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +419,Form View,Tampilan formulir
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +476,Form View,Tampilan formulir
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Ringkasan untuk bulan ini dan kegiatan yang tertunda
-apps/erpnext/erpnext/utilities/user_progress.py +227,"Add users to your organization, other than yourself.","Tambahkan pengguna ke organisasi Anda, selain dirimu sendiri."
+apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Tambahkan pengguna ke organisasi Anda, selain dirimu sendiri."
 DocType: Customer Group,Customer Group Name,Nama Kelompok Pelanggan
 apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Belum ada pelanggan
 apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Laporan arus kas
 apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Jumlah Pinjaman tidak dapat melebihi Jumlah pinjaman maksimum {0}
 apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Lisensi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +481,Please remove this Invoice {0} from C-Form {1},Hapus Invoice ini {0} dari C-Form {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +485,Please remove this Invoice {0} from C-Form {1},Hapus Invoice ini {0} dari C-Form {1}
 DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Silakan pilih Carry Teruskan jika Anda juga ingin menyertakan keseimbangan fiskal tahun sebelumnya cuti tahun fiskal ini
 DocType: GL Entry,Against Voucher Type,Terhadap Tipe Voucher
 DocType: Physician,Phone (R),Telepon (R)
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Slot waktu ditambahkan
 DocType: Item,Attributes,Atribut
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Aktifkan Template
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +223,Please enter Write Off Account,Cukup masukkan Write Off Akun
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,Cukup masukkan Write Off Akun
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Order terakhir Tanggal
 DocType: Patient,B Negative,B Negatif
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Status Pemeliharaan harus Dibatalkan atau Selesai untuk Dikirim
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Akun {0} bukan milik perusahaan {1}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +873,Serial Numbers in row {0} does not match with Delivery Note,Nomor Seri di baris {0} tidak cocok dengan Catatan Pengiriman
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +878,Serial Numbers in row {0} does not match with Delivery Note,Nomor Seri di baris {0} tidak cocok dengan Catatan Pengiriman
 DocType: Student,Guardian Details,Detail wali
 DocType: C-Form,C-Form,C-Form
 apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Kehadiran untuk beberapa karyawan
-DocType: Vehicle,Chassis No,chassis ada
+DocType: Agriculture Task,Start Day,Mulai hari
+DocType: Vehicle,Chassis No,Nomor Rangka
 DocType: Payment Request,Initiated,Diprakarsai
 DocType: Production Order,Planned Start Date,Direncanakan Tanggal Mulai
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +592,Please select a BOM,Silahkan pilih BOM
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +596,Please select a BOM,Silahkan pilih BOM
 DocType: Serial No,Creation Document Type,Pembuatan Dokumen Type
+DocType: Project Task,View Timesheet,Lihat Timesheet
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Tanggal akhir harus lebih besar dari tanggal mulai
 DocType: Leave Type,Is Encash,Apakah menjual
 DocType: Leave Allocation,New Leaves Allocated,cuti baru Dialokasikan
 apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Data proyek-bijaksana tidak tersedia untuk Quotation
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +30,End on,Akhiri
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Akhiri
 DocType: Project,Expected End Date,Diharapkan Tanggal Akhir
 DocType: Budget Account,Budget Amount,Jumlah anggaran
+DocType: Donor,Donor Name,Nama Donor
 DocType: Appraisal Template,Appraisal Template Title,Judul Template Penilaian
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Dari Tanggal {0} Karyawan {1} tidak boleh sebelum Tanggal bergabung karyawan {2}
 apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Komersial
@@ -3912,32 +4179,34 @@
 DocType: Expense Claim,More Details,Detail Lebih
 DocType: Supplier Quotation,Supplier Address,Supplier Alamat
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Anggaran untuk Akun {1} terhadap {2} {3} adalah {4}. Ini akan berlebih sebanyak {5}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +685,Row {0}# Account must be of type 'Fixed Asset',Row {0} # Akun harus bertipe &#39;Fixed Asset&#39;
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +689,Row {0}# Account must be of type 'Fixed Asset',Row {0} # Akun harus bertipe &#39;Fixed Asset&#39;
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Out Qty
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,dan Unchcked Disabled in
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Series adalah wajib
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,Jasa Keuangan
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Jasa Keuangan
 DocType: Student Sibling,Student ID,Identitas Siswa
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +457,Supplier Email,Email pemasok
 apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Jenis kegiatan untuk Waktu Log
-DocType: Tax Rule,Sales,Penjualan
+DocType: Opening Invoice Creation Tool,Sales,Penjualan
 DocType: Stock Entry Detail,Basic Amount,Nilai Dasar
 DocType: Training Event,Exam,Ujian
 DocType: Complaint,Complaint,Keluhan
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +452,Warehouse required for stock Item {0},Gudang diperlukan untuk Barang Persediaan{0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +456,Warehouse required for stock Item {0},Gudang diperlukan untuk Barang Persediaan{0}
 DocType: Leave Allocation,Unused leaves,cuti terpakai
 DocType: Patient,Alcohol Past Use,Penggunaan Alkohol yang Telah Lalu
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +179,Cr,Cr
+DocType: Fertilizer Content,Fertilizer Content,Isi pupuk
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +188,Cr,Cr
 DocType: Tax Rule,Billing State,Negara penagihan
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +276,Transfer,Transfer
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +891,Fetch exploded BOM (including sub-assemblies),Fetch meledak BOM (termasuk sub-rakitan)
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +296,Transfer,Transfer
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +916,Fetch exploded BOM (including sub-assemblies),Fetch meledak BOM (termasuk sub-rakitan)
 DocType: Authorization Rule,Applicable To (Employee),Berlaku Untuk (Karyawan)
-apps/erpnext/erpnext/controllers/accounts_controller.py +113,Due Date is mandatory,Due Date adalah wajib
+apps/erpnext/erpnext/controllers/accounts_controller.py +135,Due Date is mandatory,Due Date adalah wajib
 apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Kenaikan untuk Atribut {0} tidak dapat 0
 DocType: Journal Entry,Pay To / Recd From,Pay To / RECD Dari
 DocType: Naming Series,Setup Series,Pengaturan Series
 DocType: Payment Reconciliation,To Invoice Date,Untuk Faktur Tanggal
 DocType: Supplier,Contact HTML,Hubungi HTML
+DocType: Disease,Treatment Period,Periode Pengobatan
 ,Inactive Customers,Pelanggan tidak aktif
 DocType: Student Admission Program,Maximum Age,Usia Maksimum
 DocType: Landed Cost Voucher,LCV,LCV
@@ -3946,15 +4215,15 @@
 DocType: Stock Entry,Delivery Note No,Pengiriman Note No
 DocType: Production Planning Tool,"If checked, only Purchase material requests for final raw materials will be included in the Material Requests. Otherwise, Material Requests for parent items will be created","Jika dicentang, hanya Pembelian permintaan bahan untuk bahan baku akhir akan dimasukkan dalam Permintaan Material. Jika tidak, Permintaan Bahan untuk item orangtua akan dibuat"
 DocType: Cheque Print Template,Message to show,Pesan untuk menunjukkan
-DocType: Company,Retail,Eceran
-DocType: Attendance,Absent,Absen
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +566,Product Bundle,Bundel Produk
+apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Eceran
+DocType: Student Attendance,Absent,Absen
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Bundel Produk
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Tidak dapat menemukan skor mulai dari {0}. Anda harus memiliki nilai berdiri yang mencakup 0 sampai 100
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Row {0}: referensi tidak valid {1}
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +206,No submitted Delivery Notes found,Tidak ada catatan pengiriman yang dikirim ditemukan
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +210,Row {0}: Invalid reference {1},Row {0}: referensi tidak valid {1}
 DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Membeli Pajak dan Biaya Template
-DocType: Upload Attendance,Download Template,Unduh Template
 DocType: Timesheet,TS-,TS-
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},"{0} {1}: Salah satu dari, jumlah debit atau kredit diperlukan untuk {2}"
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Salah satu dari jumlah debit atau kredit diperlukan untuk {2}
 DocType: GL Entry,Remarks,Keterangan
 DocType: Payment Entry,Account Paid From,Akun Dibayar Dari
 DocType: Purchase Order Item Supplied,Raw Material Item Code,Bahan Baku Item Code
@@ -3963,30 +4232,34 @@
 apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Membuat Prospek
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Cetak dan Alat Tulis
 DocType: Stock Settings,Show Barcode Field,Tampilkan Barcode Lapangan
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +782,Send Supplier Emails,Kirim Email Pemasok
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +807,Send Supplier Emails,Kirim Email Pemasok
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Gaji sudah diproses untuk periode antara {0} dan {1}, Tinggalkan periode aplikasi tidak dapat antara rentang tanggal ini."
-apps/erpnext/erpnext/config/stock.py +132,Installation record for a Serial No.,Catatan instalasi untuk No Serial
 DocType: Guardian Interest,Guardian Interest,wali Tujuan
-apps/erpnext/erpnext/config/accounts.py +327,Setup default values for POS Invoices,Tetapkan nilai default untuk Faktur POS
-apps/erpnext/erpnext/config/hr.py +177,Training,Latihan
+DocType: Volunteer,Availability,Tersedianya
+apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Tetapkan nilai default untuk Faktur POS
+apps/erpnext/erpnext/config/hr.py +182,Training,Latihan
 DocType: Timesheet,Employee Detail,Detil karyawan
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,ID Email Guardian1
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,ID Email Guardian1
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Hari berikutnya Tanggal dan Ulangi pada Hari Bulan harus sama
 DocType: Lab Prescription,Test Code,Kode uji
 apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Pengaturan untuk homepage website
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +38,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ tidak diizinkan untuk {0} karena kartu skor berdiri dari {1}
+DocType: Delivery Stop,Select/Unselect Delivery Notes,Pilih / Hapus pilihan Catatan Pengiriman
 DocType: Offer Letter,Awaiting Response,Menunggu Respon
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Di atas
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1298,Total Amount {0},Jumlah Total {0}
-apps/erpnext/erpnext/controllers/item_variant.py +232,Invalid attribute {0} {1},atribut tidak valid {0} {1}
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1375,Total Amount {0},Jumlah Total {0}
+apps/erpnext/erpnext/controllers/item_variant.py +301,Invalid attribute {0} {1},atribut tidak valid {0} {1}
 DocType: Supplier,Mention if non-standard payable account,Sebutkan jika akun hutang non-standar
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Harap pilih kelompok penilaian selain &#39;Semua Kelompok Penilaian&#39;
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Harap pilih kelompok penilaian selain &#39;Semua Kelompok Penilaian&#39;
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Baris {0}: Pusat biaya diperlukan untuk item {1}
 DocType: Training Event Employee,Optional,Pilihan
 DocType: Salary Slip,Earning & Deduction,Earning & Pengurangan
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,Opsional. Pengaturan ini akan digunakan untuk menyaring dalam berbagai transaksi.
+DocType: Agriculture Analysis Criteria,Water Analysis,Analisis air
+DocType: Chapter,Region,Wilayah
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Opsional. Pengaturan ini akan digunakan untuk menyaring dalam berbagai transaksi.
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +108,Negative Valuation Rate is not allowed,Tingkat Penilaian negatif tidak diperbolehkan
 DocType: Holiday List,Weekly Off,Weekly Off
+apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Reload Linked Analysis
 DocType: Fiscal Year,"For e.g. 2012, 2012-13","Untuk misalnya 2012, 2012-13"
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Laba Provisional / Rugi (Kredit)
 DocType: Sales Invoice,Return Against Sales Invoice,Retur Terhadap Faktur Penjualan
@@ -3998,11 +4271,10 @@
 ,Monthly Attendance Sheet,Lembar Kehadiran Bulanan
 DocType: Production Order Item,Production Order Item,Produksi Pesanan Barang
 apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Tidak ada catatan ditemukan
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost of Scrapped Asset,Biaya Asset dibatalkan
-apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},"{0} {1}: ""Cost Center"" adalah wajib untuk Item {2}"
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Biaya Asset dibatalkan
+apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},"{0} {1}: ""Pusat Biaya"" adalah wajib untuk Item {2}"
 DocType: Vehicle,Policy No,Kebijakan Tidak ada
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +659,Get Items from Product Bundle,Dapatkan Barang-barang dari Bundel Produk
-apps/erpnext/erpnext/stock/doctype/item/item.py +663,"As stock exists against an item {0}, you can not enable has variants property","Karena ada stok terhadap item {0}, Anda tidak dapat mengaktifkan memiliki varian properti"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +684,Get Items from Product Bundle,Dapatkan Barang-barang dari Bundel Produk
 DocType: Asset,Straight Line,Garis lurus
 DocType: Project User,Project User,proyek Pengguna
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +64,Split,Membagi
@@ -4013,6 +4285,8 @@
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Tanggal Komunikasi Terakhir
 DocType: Sales Team,Contact No.,Hubungi Nomor
 DocType: Bank Reconciliation,Payment Entries,Entries pembayaran
+DocType: Land Unit,Land Unit Details,Rincian Unit Tanah
+DocType: Land Unit,Latitude,Lintang
 DocType: Production Order,Scrap Warehouse,Gudang memo
 DocType: Production Order,Check if material transfer entry is not required,Periksa apakah entri pemindahan material tidak diperlukan
 DocType: Program Enrollment Tool,Get Students From,Dapatkan Siswa Dari
@@ -4025,77 +4299,83 @@
 DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Penjualan Pajak dan Biaya Template
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Total (Kredit)
 DocType: Repayment Schedule,Payment Date,Tanggal pembayaran
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +107,New Batch Qty,Baru Batch Qty
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +10,Apparel & Accessories,Pakaian & Aksesoris
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +114,New Batch Qty,Baru Batch Qty
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Pakaian & Aksesoris
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,Tidak dapat memecahkan fungsi skor tertimbang. Pastikan rumusnya benar.
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Jumlah Order
 DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner yang akan muncul di bagian atas daftar produk.
 DocType: Shipping Rule,Specify conditions to calculate shipping amount,Tentukan kondisi untuk menghitung jumlah pengiriman
+DocType: Program Enrollment,Institute's Bus,Bus Institut
 DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Peran Diizinkan Set Beku Account & Edit Frozen Entri
 DocType: Supplier Scorecard Scoring Variable,Path,Jalan
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,Tidak dapat mengkonversi Pusat Biaya untuk buku karena memiliki node anak
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +56,Opening Value,Nilai pembukaan
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +66,Opening Value,Nilai pembukaan
 DocType: Salary Detail,Formula,Rumus
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
 DocType: Lab Test Template,Lab Test Template,Lab Test Template
+DocType: Purchase Invoice Item,Total Weight,Berat keseluruhan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Komisi Penjualan
 DocType: Offer Letter Term,Value / Description,Nilai / Keterangan
-apps/erpnext/erpnext/controllers/accounts_controller.py +565,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Aset {1} tidak dapat disampaikan, itu sudah {2}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +609,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Aset {1} tidak dapat disampaikan, itu sudah {2}"
 DocType: Tax Rule,Billing Country,Negara Penagihan
 DocType: Purchase Order Item,Expected Delivery Date,Diharapkan Pengiriman Tanggal
 DocType: Restaurant Order Entry,Restaurant Order Entry,Entri Pemesanan Restoran
 apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debit dan Kredit tidak sama untuk {0} # {1}. Perbedaan adalah {2}.
+DocType: Asset Maintenance Task,Assign To Name,Berikan nama
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Beban Hiburan
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +48,Make Material Request,Membuat Material Permintaan
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +63,Make Material Request,Membuat Material Permintaan
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Terbuka Barang {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktur Penjualan {0} harus dibatalkan sebelum membatalkan Sales Order ini
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktur Penjualan {0} harus dibatalkan sebelum membatalkan Sales Order ini
 DocType: Consultation,Age,Usia
 DocType: Sales Invoice Timesheet,Billing Amount,Jumlah Penagihan
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Kuantitas tidak valid untuk item {0}. Jumlah harus lebih besar dari 0.
+DocType: Company,Default Employee Advance Account,Akun uang muka karyawan
 apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Aplikasi untuk cuti.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account with existing transaction can not be deleted,Akun dengan transaksi yang ada tidak dapat dihapus
+apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Account with existing transaction can not be deleted,Akun dengan transaksi yang ada tidak dapat dihapus
 DocType: Vehicle,Last Carbon Check,Terakhir Carbon Periksa
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Beban Legal
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +130,Please select quantity on row ,Silakan pilih kuantitas pada baris
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Silakan pilih kuantitas pada baris
+apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Lakukan Pembukaan Faktur Penjualan dan Pembelian
 DocType: Purchase Invoice,Posting Time,Posting Waktu
 DocType: Timesheet,% Amount Billed,% Jumlah Ditagih
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.",&quot;Time Per Appointment&quot; belum ditetapkan untuk Dr {0}. Tambahkan ke master Doctor.
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.","""Waktu Per Pertemuan"" belum ditetapkan untuk Dr {0}. Tambahkan ke data utama Dokter."
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Beban Telepon
 DocType: Sales Partner,Logo,Logo
 DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Periksa ini jika Anda ingin untuk memaksa pengguna untuk memilih seri sebelum menyimpan. Tidak akan ada default jika Anda memeriksa ini.
-apps/erpnext/erpnext/stock/get_item_details.py +135,No Item with Serial No {0},Tidak ada Stok Barang dengan Serial No {0}
+apps/erpnext/erpnext/stock/get_item_details.py +129,No Item with Serial No {0},Tidak ada Stok Barang dengan Serial No {0}
 DocType: Email Digest,Open Notifications,Terbuka Pemberitahuan
 DocType: Payment Entry,Difference Amount (Company Currency),Perbedaan Jumlah (Perusahaan Mata Uang)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Beban Langsung
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Silakan setup Sistem Penamaan Instruktur di Pendidikan&gt; Pengaturan Pendidikan
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Pendapatan Pelanggan Baru
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Biaya Perjalanan
 DocType: Maintenance Visit,Breakdown,Rincian
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Tambahkan bidang kustom Langganan di doctype {0}
-apps/erpnext/erpnext/controllers/accounts_controller.py +677,Account: {0} with currency: {1} can not be selected,Account: {0} dengan mata uang: {1} tidak dapat dipilih
+apps/erpnext/erpnext/controllers/accounts_controller.py +789,Account: {0} with currency: {1} can not be selected,Account: {0} dengan mata uang: {1} tidak dapat dipilih
+DocType: Purchase Receipt Item,Sample Quantity,Jumlah sampel
 DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Update biaya BOM secara otomatis melalui Scheduler, berdasarkan tingkat penilaian / harga daftar penilaian terakhir / tingkat pembelian terakhir bahan baku."
 DocType: Bank Reconciliation Detail,Cheque Date,Cek Tanggal
-apps/erpnext/erpnext/accounts/doctype/account/account.py +54,Account {0}: Parent account {1} does not belong to company: {2},Akun {0}: akun Induk {1} bukan milik perusahaan: {2}
+apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Akun {0}: akun Induk {1} bukan milik perusahaan: {2}
 DocType: Program Enrollment Tool,Student Applicants,Pelamar mahasiswa
 apps/erpnext/erpnext/setup/doctype/company/company.js +77,Successfully deleted all transactions related to this company!,Berhasil dihapus semua transaksi yang terkait dengan perusahaan ini!
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Seperti pada Tanggal
 DocType: Appraisal,HR,HR
 DocType: Program Enrollment,Enrollment Date,tanggal pendaftaran
 DocType: Healthcare Settings,Out Patient SMS Alerts,SMS Pemberitahuan Pasien Luar
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +96,Probation,Percobaan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,Percobaan
 apps/erpnext/erpnext/config/hr.py +115,Salary Components,Komponen gaji
 DocType: Program Enrollment Tool,New Academic Year,Baru Tahun Akademik
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +762,Return / Credit Note,Nota Retur / Kredit
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +809,Return / Credit Note,Nota Retur / Kredit
 DocType: Stock Settings,Auto insert Price List rate if missing,Insert auto tingkat Daftar Harga jika hilang
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23,Total Paid Amount,Jumlah Total Dibayar
 DocType: Production Order Item,Transferred Qty,Ditransfer Qty
 apps/erpnext/erpnext/config/learn.py +11,Navigating,Menjelajahi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +184,Planning,Perencanaan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Perencanaan
 DocType: Material Request,Issued,Diterbitkan
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +14,Student Activity,Kegiatan Siswa
-DocType: Project,Total Billing Amount (via Time Logs),Jumlah Total Tagihan (via Waktu Log)
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Kegiatan Siswa
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Supplier Id
 DocType: Payment Request,Payment Gateway Details,Pembayaran Detail Gateway
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +264,Quantity should be greater than 0,Kuantitas harus lebih besar dari 0
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +267,Quantity should be greater than 0,Kuantitas harus lebih besar dari 0
 DocType: Journal Entry,Cash Entry,Entri Kas
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,node anak hanya dapat dibuat di bawah &#39;Grup&#39; Jenis node
 DocType: Leave Application,Half Day Date,Tanggal Setengah Hari
@@ -4104,22 +4384,25 @@
 apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Jenis cuti seperti kasual, dll sakit"
 DocType: Email Digest,Send regular summary reports via Email.,Mengirim laporan ringkasan berkala melalui Email.
 DocType: Payment Entry,PE-,PE-
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +254,Please set default account in Expense Claim Type {0},Silakan set account default di Beban Klaim Jenis {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +305,Please set default account in Expense Claim Type {0},Silakan set account default di Beban Klaim Jenis {0}
 DocType: Assessment Result,Student Name,Nama siswa
 DocType: Brand,Item Manager,Item Manajer
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Payroll Hutang
 DocType: Buying Settings,Default Supplier Type,Standar Supplier Type
+DocType: Plant Analysis,Collection Datetime,Koleksi Datetime
 DocType: Production Order,Total Operating Cost,Total Biaya Operasional
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Catatan: Stok Barang {0} masuk beberapa kali
 apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Semua Kontak.
-apps/erpnext/erpnext/public/js/setup_wizard.js +67,Company Abbreviation,Singkatan Perusahaan
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Singkatan Perusahaan
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Pengguna {0} tidak ada
+DocType: Payment Term,Day(s) after invoice date,Hari setelah tanggal faktur
+DocType: Payment Schedule,Payment Schedule,Jadwal pembayaran
 DocType: Subscription,SUB-,SUB-
 DocType: Item Attribute Value,Abbreviation,Singkatan
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,Masuk pembayaran sudah ada
 apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Tidak Authroized sejak {0} melebihi batas
 apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Template master gaji.
-apps/erpnext/erpnext/healthcare/setup.py +240,Pathology,Patologi
+apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Patologi
 DocType: Restaurant Order Entry,Restaurant Table,Meja restoran
 DocType: Leave Type,Max Days Leave Allowed,Max Hari Cuti Diizinkan
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Set Peraturan Pajak untuk keranjang belanja
@@ -4132,52 +4415,56 @@
 apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Penawaran terhadap Prospek atau Pelanggan
 DocType: Stock Settings,Role Allowed to edit frozen stock,Peran diizinkan mengedit persediaan dibekukan
 ,Territory Target Variance Item Group-Wise,Wilayah Sasaran Variance Stok Barang Group-Wise
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +139,All Customer Groups,Semua Kelompok Pelanggan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Semua Kelompok Pelanggan
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,akumulasi Bulanan
-apps/erpnext/erpnext/controllers/accounts_controller.py +638,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} adalah wajib. Mungkin data Kurs Mata Uang tidak dibuat untuk {1} sampai {2}.
+apps/erpnext/erpnext/controllers/accounts_controller.py +750,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} adalah wajib. Mungkin data Kurs Mata Uang tidak dibuat untuk {1} sampai {2}.
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +41,Tax Template is mandatory.,Template pajak adalah wajib.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} does not exist,Akun {0}: akun Induk {1} tidak ada
+apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Akun {0}: akun Induk {1} tidak ada
 DocType: Purchase Invoice Item,Price List Rate (Company Currency),Daftar Harga Rate (Perusahaan Mata Uang)
 DocType: Products Settings,Products Settings,Pengaturan produk
+,Item Price Stock,Stok Harga Barang
 DocType: Lab Prescription,Test Created,Uji coba
 DocType: Healthcare Settings,Custom Signature in Print,Tanda Tangan Khusus di Cetak
 DocType: Account,Temporary,Sementara
 DocType: Program,Courses,Kursus
 DocType: Monthly Distribution Percentage,Percentage Allocation,Persentase Alokasi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +124,Secretary,Sekretaris
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Sekretaris
 DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Jika menonaktifkan, &#39;Dalam Kata-kata&#39; bidang tidak akan terlihat di setiap transaksi"
 DocType: Serial No,Distinct unit of an Item,Unit berbeda Item
 DocType: Supplier Scorecard Criteria,Criteria Name,Nama kriteria
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1213,Please set Company,Harap set Perusahaan
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1289,Please set Company,Harap set Perusahaan
 DocType: Pricing Rule,Buying,Pembelian
+apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Penyakit &amp; Pupuk
 DocType: HR Settings,Employee Records to be created by,Rekaman Karyawan yang akan dibuat oleh
 DocType: Patient,AB Negative,AB Negatif
 DocType: Sample Collection,SMPL-,SMPL-
 DocType: POS Profile,Apply Discount On,Terapkan Diskon Pada
+DocType: Member,Membership Type,jenis keanggotaan
 ,Reqd By Date,Reqd By Date
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Kreditor
 DocType: Assessment Plan,Assessment Name,penilaian Nama
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Row # {0}: Serial ada adalah wajib
 DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Stok Barang Wise Detil Pajak
-apps/erpnext/erpnext/public/js/setup_wizard.js +67,Institute Abbreviation,Singkatan Institute
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Singkatan Institute
 ,Item-wise Price List Rate,Stok Barang-bijaksana Daftar Harga Tingkat
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941,Supplier Quotation,Supplier Quotation
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +966,Supplier Quotation,Supplier Quotation
 DocType: Quotation,In Words will be visible once you save the Quotation.,Dalam Kata-kata akan terlihat sekali Anda menyimpan Quotation tersebut.
 apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},Kuantitas ({0}) tidak boleh menjadi pecahan dalam baris {1}
 DocType: Consultation,C-,C-
 DocType: Attendance,ATT-,ATT-
-apps/erpnext/erpnext/stock/doctype/item/item.py +457,Barcode {0} already used in Item {1},Barcode {0} sudah digunakan dalam Produk {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +473,Barcode {0} already used in Item {1},Barcode {0} sudah digunakan dalam Produk {1}
 apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Aturan untuk menambahkan biaya pengiriman.
 DocType: Item,Opening Stock,Persediaan pembukaan
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Pelanggan diwajibkan
 DocType: Lab Test,Result Date,Tanggal hasil
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} adalah wajib untuk Retur
 DocType: Purchase Order,To Receive,Menerima
-apps/erpnext/erpnext/utilities/user_progress.py +231,user@example.com,user@example.com
+apps/erpnext/erpnext/utilities/user_progress.py +249,user@example.com,user@example.com
+DocType: Asset,Asset Owner,Pemilik aset
 DocType: Employee,Personal Email,Email Pribadi
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Total Variance
 DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Jika diaktifkan, sistem akan posting entri akuntansi untuk persediaan otomatis."
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +15,Brokerage,Memperantarai
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Memperantarai
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Kehadiran bagi karyawan {0} sudah ditandai untuk hari ini
 DocType: Production Order Operation,"in Minutes
 Updated via 'Time Log'","di Menit 
@@ -4185,15 +4472,15 @@
 DocType: Customer,From Lead,Dari Prospek
 apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Order dirilis untuk produksi.
 apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Pilih Tahun Anggaran ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +557,POS Profile required to make POS Entry,POS Profil diperlukan untuk membuat POS Entri
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +561,POS Profile required to make POS Entry,POS Profil diperlukan untuk membuat POS Entri
 DocType: Program Enrollment Tool,Enroll Students,Daftarkan Siswa
 DocType: Lab Test,Approved Date,Tanggal yang Disetujui
 apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standard Jual
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +138,Atleast one warehouse is mandatory,Setidaknya satu gudang adalah wajib
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +143,Atleast one warehouse is mandatory,Setidaknya satu gudang adalah wajib
 DocType: Serial No,Out of Warranty,Out of Garansi
 DocType: BOM Update Tool,Replace,Mengganti
 apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Tidak ditemukan produk.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} terhadap Faktur Penjualan {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +358,{0} against Sales Invoice {1},{0} terhadap Faktur Penjualan {1}
 DocType: Antibiotic,Laboratory User,Pengguna Laboratorium
 DocType: Sales Invoice,SINV-,SINV-
 DocType: Request for Quotation Item,Project Name,Nama Proyek
@@ -4203,43 +4490,47 @@
 DocType: Stock Ledger Entry,Stock Value Difference,Perbedaan Nilai Persediaan
 apps/erpnext/erpnext/config/learn.py +234,Human Resource,Sumber Daya Manusia
 DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Rekonsiliasi Pembayaran Pembayaran
+DocType: Disease,Treatment Task,Tugas Pengobatan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Aset pajak
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +626,Production Order has been {0},Pesanan Produksi telah {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +630,Production Order has been {0},Pesanan Produksi telah {0}
 DocType: BOM Item,BOM No,No. BOM
 DocType: Instructor,INS/,INS /
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,Journal Entry {0} does not have account {1} or already matched against other voucher,Jurnal Entri {0} tidak memiliki akun {1} atau sudah dicocokkan voucher lainnya
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +158,Journal Entry {0} does not have account {1} or already matched against other voucher,Jurnal Entri {0} tidak memiliki akun {1} atau sudah dicocokkan voucher lainnya
 DocType: Item,Moving Average,Moving Average
 DocType: BOM Update Tool,The BOM which will be replaced,BOM yang akan diganti
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,Peralatan elektronik
+DocType: Asset,Maintenance Required,Pemeliharaan Diperlukan
 DocType: Account,Debit,Debet
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"cuti harus dialokasikan dalam kelipatan 0,5"
 DocType: Production Order,Operation Cost,Biaya Operasi
 apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Unggah kehadiran dari file csv.
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Posisi Amt
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Posisi Amt
 DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Target Set Stok Barang Group-bijaksana untuk Sales Person ini.
 DocType: Stock Settings,Freeze Stocks Older Than [Days],Bekukan Persediaan Lebih Lama Dari [Hari]
-apps/erpnext/erpnext/controllers/accounts_controller.py +535,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Aset adalah wajib untuk aktiva tetap pembelian / penjualan
+apps/erpnext/erpnext/controllers/accounts_controller.py +579,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Aset adalah wajib untuk aktiva tetap pembelian / penjualan
+DocType: Asset Maintenance Team,Maintenance Team Name,Nama Tim Pemeliharaan
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Jika dua atau lebih Aturan Harga yang ditemukan berdasarkan kondisi di atas, Prioritas diterapkan. Prioritas adalah angka antara 0 sampai 20, sementara nilai default adalah nol (kosong). Jumlah yang lebih tinggi berarti akan diutamakan jika ada beberapa Aturan Harga dengan kondisi yang sama."
 apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Tahun Anggaran: {0} tidak ada
 DocType: Currency Exchange,To Currency,Untuk Mata
 DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Izinkan pengguna ini untuk menyetujui aplikasi izin cuti untuk hari yang terpilih(blocked).
-apps/erpnext/erpnext/config/hr.py +132,Types of Expense Claim.,Jenis Beban Klaim.
-apps/erpnext/erpnext/controllers/selling_controller.py +176,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Tingkat penjualan untuk item {0} lebih rendah dari {1} nya. Tingkat penjualan harus atleast {2}
+apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Jenis Beban Klaim.
+apps/erpnext/erpnext/controllers/selling_controller.py +144,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Tingkat penjualan untuk item {0} lebih rendah dari {1} nya. Tingkat penjualan harus atleast {2}
 DocType: Item,Taxes,PPN
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +324,Paid and Not Delivered,Dibayar dan Tidak Terkirim
+DocType: Purchase Invoice Item,Weight Per Unit,Berat Per Unit
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Dibayar dan Tidak Terkirim
 DocType: Project,Default Cost Center,Standar Biaya Pusat
 DocType: Bank Guarantee,End Date,Tanggal Berakhir
 apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Transaksi Persediaan
 DocType: Budget,Budget Accounts,Akun anggaran
 DocType: Employee,Internal Work History,Sejarah Kerja internal
 DocType: Depreciation Schedule,Accumulated Depreciation Amount,Akumulasi Penyusutan Jumlah
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Private Equity
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity
 DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Supplier Scorecard Variabel
 DocType: Employee Loan,Fully Disbursed,sepenuhnya Dicairkan
 DocType: Maintenance Visit,Customer Feedback,Umpan balik Pelanggan
 DocType: Account,Expense,Biaya
-apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Skor tidak dapat lebih besar dari skor maksimum
-apps/erpnext/erpnext/utilities/user_progress.py +108,Customers and Suppliers,Pelanggan dan Pemasok
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Skor tidak dapat lebih besar dari skor maksimum
+apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Pelanggan dan Pemasok
 DocType: Item Attribute,From Range,Dari Rentang
 DocType: BOM,Set rate of sub-assembly item based on BOM,Tetapkan tarif barang sub-rakitan berdasarkan BOM
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},kesalahan sintaks dalam formula atau kondisi: {0}
@@ -4248,6 +4539,7 @@
 DocType: Appraisal,APRSL,APRSL
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Submit this Production Order for further processing.,Kirim Produksi ini Order untuk diproses lebih lanjut.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Untuk tidak berlaku Rule Harga dalam transaksi tertentu, semua Aturan Harga yang berlaku harus dinonaktifkan."
+DocType: Payment Term,Day(s) after the end of the invoice month,Hari setelah akhir bulan faktur
 DocType: Assessment Group,Parent Assessment Group,Induk Penilaian Grup
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Pekerjaan
 ,Sales Order Trends,Sales Order Trends
@@ -4256,21 +4548,23 @@
 ,Employee Information,Informasi Karyawan
 DocType: Stock Entry Detail,Additional Cost,Biaya tambahan
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"Can not filter based on Voucher No, if grouped by Voucher","Tidak dapat memfilter berdasarkan No. Voucher, jika dikelompokkan berdasarkan Voucher"
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +891,Make Supplier Quotation,Membuat Pemasok Quotation
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +916,Make Supplier Quotation,Membuat Pemasok Quotation
 DocType: Quality Inspection,Incoming,Incoming
-apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Catatan Hasil Penilaian {0} sudah ada.
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Catatan Hasil Penilaian {0} sudah ada.
 DocType: BOM,Materials Required (Exploded),Bahan yang dibutuhkan (Meledak)
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',Harap tentukan filter Perusahaan jika Group By &#39;Company&#39;
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Posting Tanggal tidak bisa tanggal di masa depan
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} tidak sesuai dengan {2} {3}
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,untuk menghasilkan berulang
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +82,Casual Leave,Santai Cuti
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Santai Cuti
 apps/erpnext/erpnext/config/healthcare.py +138,Lab Test UOM.,Uji Lab UOM.
+DocType: Agriculture Task,End Day,Hari Akhir
 DocType: Batch,Batch ID,Batch ID
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Catatan: {0}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Catatan: {0}
 ,Delivery Note Trends,Tren pengiriman Note
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Ringkasan minggu ini
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +20,In Stock Qty,Jumlah tersedia
+DocType: Delivery Trip,Calculate Estimated Arrival Times,Hitung Perkiraan Waktu Kedatangan
 apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Akun: {0} hanya dapat diperbarui melalui Transaksi Persediaan
 DocType: Student Group Creation Tool,Get Courses,Dapatkan Program
 DocType: GL Entry,Party,Pihak
@@ -4279,59 +4573,68 @@
 DocType: Sales Order,Delivery Date,Tanggal Pengiriman
 DocType: Opportunity,Opportunity Date,Peluang Tanggal
 DocType: Purchase Receipt,Return Against Purchase Receipt,Retur Terhadap Nota Pembelian
+DocType: Water Analysis,Person Responsible,Orang yang bertanggung jawab
 DocType: Request for Quotation Item,Request for Quotation Item,Permintaan Quotation Barang
 DocType: Purchase Order,To Bill,Bill
 DocType: Material Request,% Ordered,% Tersusun
-DocType: School Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Untuk Kelompok Siswa Berbasis Kursus, Kursus akan divalidasi untuk setiap Siswa dari Program Pendaftaran Pendaftaran Program yang terdaftar."
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +99,Piecework,Pekerjaan yg dibayar menurut hasil yg dikerjakan
+DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Untuk Kelompok Siswa Berbasis Kursus, Kursus akan divalidasi untuk setiap Siswa dari Program Pendaftaran Pendaftaran Program yang terdaftar."
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Pekerjaan yg dibayar menurut hasil yg dikerjakan
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Buying Rate,Harga Beli Rata-rata
 DocType: Task,Actual Time (in Hours),Waktu Aktual (dalam Jam)
 DocType: Employee,History In Company,Sejarah Dalam Perusahaan
 apps/erpnext/erpnext/config/learn.py +107,Newsletters,Surat edaran
 DocType: Drug Prescription,Description/Strength,Deskripsi / Kekuatan
 DocType: Stock Ledger Entry,Stock Ledger Entry,Entri Buku Persediaan
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +82,Same item has been entered multiple times,item yang sama telah dimasukkan beberapa kali
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,item yang sama telah dimasukkan beberapa kali
 DocType: Department,Leave Block List,Cuti Block List
-DocType: Sales Invoice,Tax ID,Id pajak
+DocType: Purchase Invoice,Tax ID,Id pajak
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,Stok Barang {0} tidak diatur untuk Nomor Seri. Kolom harus kosong
 DocType: Accounts Settings,Accounts Settings,Pengaturan Akun
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +38,Approve,Menyetujui
-apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +149,No Result to submit,Tidak ada hasil untuk disampaikan
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,Menyetujui
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +51,"Malformatted address for {0}, please fix to continue.","Alamat berformat salah untuk {0}, tolong perbaiki untuk melanjutkan."
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix","Jumlah Akun baru, akan disertakan dalam nama akun sebagai awalan"
+DocType: Maintenance Team Member,Team Member,Anggota tim
+apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Tidak ada hasil untuk disampaikan
 DocType: Customer,Sales Partner and Commission,Penjualan Mitra dan Komisi
 DocType: Employee Loan,Rate of Interest (%) / Year,Tingkat bunga (%) / Tahun
 ,Project Quantity,proyek Kuantitas
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Total {0} untuk semua item adalah nol, mungkin Anda harus mengubah &#39;Distribusikan Biaya Berdasarkan&#39;"
 DocType: Opportunity,To Discuss,Untuk Diskusikan
-apps/erpnext/erpnext/stock/stock_ledger.py +368,{0} units of {1} needed in {2} to complete this transaction.,{0} unit {1} dibutuhkan dalam {2} untuk menyelesaikan transaksi ini.
+apps/erpnext/erpnext/stock/stock_ledger.py +375,{0} units of {1} needed in {2} to complete this transaction.,{0} unit {1} dibutuhkan dalam {2} untuk menyelesaikan transaksi ini.
 DocType: Loan Type,Rate of Interest (%) Yearly,Tingkat bunga (%) Tahunan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Akun sementara
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +203,Black,Hitam
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Hitam
 DocType: BOM Explosion Item,BOM Explosion Item,BOM Ledakan Stok Barang
 DocType: Account,Auditor,Akuntan
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} item diproduksi
 apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Belajarlah lagi
 DocType: Cheque Print Template,Distance from top edge,Jarak dari tepi atas
-apps/erpnext/erpnext/stock/get_item_details.py +317,Price List {0} is disabled or does not exist,Daftar Harga {0} dinonaktifkan atau tidak ada
+apps/erpnext/erpnext/stock/get_item_details.py +360,Price List {0} is disabled or does not exist,Daftar Harga {0} dinonaktifkan atau tidak ada
 DocType: Purchase Invoice,Return,Retur
 DocType: Production Order Operation,Production Order Operation,Order Operasi Produksi
 DocType: Pricing Rule,Disable,Nonaktifkan
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +161,Mode of payment is required to make a payment,Cara pembayaran yang diperlukan untuk melakukan pembayaran
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Mode of payment is required to make a payment,Cara pembayaran yang diperlukan untuk melakukan pembayaran
 DocType: Project Task,Pending Review,Pending Ulasan
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Edit di halaman penuh untuk lebih banyak pilihan seperti aset, serial nos, batch dll."
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Janji dan Konsultasi
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} tidak terdaftar dalam Batch {2}
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Aset {0} tidak dapat dihapus, karena sudah {1}"
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} tidak terdaftar dalam Batch {2}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Aset {0} tidak dapat dihapus, karena sudah {1}"
 DocType: Task,Total Expense Claim (via Expense Claim),Jumlah Klaim Beban (via Beban Klaim)
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Absen
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Gagal menata perusahaan
+DocType: Asset Repair,Asset Repair,Perbaikan Aset
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +140,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Row {0}: Mata dari BOM # {1} harus sama dengan mata uang yang dipilih {2}
 DocType: Journal Entry Account,Exchange Rate,Nilai Tukar
 DocType: Patient,Additional information regarding the patient,Informasi tambahan mengenai pasien
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +575,Sales Order {0} is not submitted,Order Penjualan {0} tidak Terkirim
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +579,Sales Order {0} is not submitted,Order Penjualan {0} tidak Terkirim
 DocType: Homepage,Tag Line,klimaks
 DocType: Fee Component,Fee Component,biaya Komponen
-apps/erpnext/erpnext/config/hr.py +199,Fleet Management,Manajemen armada
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +939,Add items from,Menambahkan item dari
+apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Manajemen armada
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +964,Add items from,Menambahkan item dari
+apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Tanaman &amp; lahan
 DocType: Cheque Print Template,Regular,Reguler
-apps/erpnext/erpnext/schools/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Total weightage semua Kriteria Penilaian harus 100%
+DocType: Fertilizer,Density (if liquid),Densitas (jika cair)
+apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Total weightage semua Kriteria Penilaian harus 100%
 DocType: Purchase Order Item,Last Purchase Rate,Tingkat Pembelian Terakhir
 DocType: Account,Asset,Aset
 DocType: Project Task,Task ID,Tugas ID
@@ -4341,29 +4644,33 @@
 DocType: Training Event,Contact Number,Nomor kontak
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Gudang {0} tidak ada
 DocType: Monthly Distribution,Monthly Distribution Percentages,Persentase Distribusi bulanan
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +37,The selected item cannot have Batch,Item yang dipilih tidak dapat memiliki Batch
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +38,The selected item cannot have Batch,Item yang dipilih tidak dapat memiliki Batch
 DocType: Delivery Note,% of materials delivered against this Delivery Note,% Dari materi yang Terkirim terhadap Pengiriman ini Note
-DocType: Training Event,Has Certificate,Memiliki sertifikat
+DocType: Asset Maintenance Log,Has Certificate,Memiliki sertifikat
 DocType: Project,Customer Details,Rincian Pelanggan
+DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Periksa apakah Aset memerlukan Pemeliharaan atau Kalibrasi Pencegahan
 DocType: Employee,Reports to,Laporan untuk
 ,Unpaid Expense Claim,Tunggakan Beban Klaim
 DocType: Payment Entry,Paid Amount,Dibayar Jumlah
-apps/erpnext/erpnext/utilities/user_progress.py +137,Explore Sales Cycle,Jelajahi Siklus Penjualan
+apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Jelajahi Siklus Penjualan
 DocType: Assessment Plan,Supervisor,Pengawas
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +73,Online,On line
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +70,Online,On line
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +867,Retention Stock Entry,Entri saham retensi
 ,Available Stock for Packing Items,Tersedia untuk Barang Paket
 DocType: Item Variant,Item Variant,Item Variant
 DocType: Assessment Result Tool,Assessment Result Tool,Alat Hasil penilaian
 DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Barang
-apps/erpnext/erpnext/accounts/page/pos/pos.js +871,Submitted orders can not be deleted,perintah yang disampaikan tidak dapat dihapus
-apps/erpnext/erpnext/accounts/doctype/account/account.py +117,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Saldo rekening sudah berada di Debit, Anda tidak diizinkan untuk mengatur 'Balance Harus' sebagai 'Kredit'"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +114,Quality Management,Manajemen Mutu
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +41,Item {0} has been disabled,Item {0} telah dinonaktifkan
+apps/erpnext/erpnext/accounts/page/pos/pos.js +886,Submitted orders can not be deleted,perintah yang disampaikan tidak dapat dihapus
+apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Saldo rekening sudah berada di Debit, Anda tidak diizinkan untuk mengatur 'Balance Harus' sebagai 'Kredit'"
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Manajemen Mutu
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Item {0} telah dinonaktifkan
+DocType: Project,Total Billable Amount (via Timesheets),Total Jumlah yang Dapat Ditagih (via Timesheets)
+DocType: Agriculture Task,Previous Business Day,Hari Bisnis Sebelumnya
 DocType: Employee Loan,Repay Fixed Amount per Period,Membayar Jumlah Tetap per Periode
 apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Mohon masukkan untuk Item {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Credit Note Amt,Catatan Kredit Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Credit Note Amt,Catatan Kredit Amt
 DocType: Employee External Work History,Employee External Work History,Karyawan Eksternal Riwayat Pekerjaan
-DocType: Tax Rule,Purchase,Pembelian
+DocType: Opening Invoice Creation Tool,Purchase,Pembelian
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Jumlah Saldo
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Tujuan tidak boleh kosong
 DocType: Item Group,Parent Item Group,Induk Stok Barang Grup
@@ -4371,23 +4678,25 @@
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} untuk {1}
 DocType: Healthcare Settings,Valid number of days,Jumlah hari yang valid
 apps/erpnext/erpnext/setup/doctype/company/company.js +35,Cost Centers,Pusat biaya
+DocType: Land Unit,Linked Plant Analysis,Analisis Tanaman Tertanam
 DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Tingkat di mana mata uang Supplier dikonversi ke mata uang dasar perusahaan
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: konflik Timing dengan baris {1}
 DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Biarkan Zero Valuation Rate
 DocType: Training Event Employee,Invited,diundang
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Beberapa Struktur Gaji aktif yang ditemukan untuk karyawan {0} untuk tanggal tertentu
-apps/erpnext/erpnext/config/accounts.py +316,Setup Gateway accounts.,Rekening Gateway setup.
+apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Rekening Gateway setup.
 DocType: Employee,Employment Type,Jenis Pekerjaan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Aktiva Tetap
 DocType: Payment Entry,Set Exchange Gain / Loss,Set Efek Gain / Loss
 ,GST Purchase Register,Daftar Pembelian GST
 ,Cash Flow,Arus kas
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Periode aplikasi tidak bisa di dua catatan alokasi
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Bagian invoice gabungan harus sama dengan 100%
 DocType: Item Group,Default Expense Account,Beban standar Akun
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,ID Email Siswa
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,ID Email Siswa
 DocType: Employee,Notice (days),Notice (hari)
 DocType: Tax Rule,Sales Tax Template,Template Pajak Penjualan
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2448,Select items to save the invoice,Pilih item untuk menyimpan faktur
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2467,Select items to save the invoice,Pilih item untuk menyimpan faktur
 DocType: Employee,Encashment Date,Pencairan Tanggal
 DocType: Training Event,Internet,Internet
 DocType: Special Test Template,Special Test Template,Template Uji Khusus
@@ -4397,6 +4706,7 @@
 DocType: Academic Term,Term Start Date,Jangka Mulai Tanggal
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +242,Please find attached {0} #{1},Silakan menemukan terlampir {0} # {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +701,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Jumlah Pembayaran Total dalam Jadwal Pembayaran harus sama dengan Grand / Rounded Total
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Bank saldo Laporan per General Ledger
 DocType: Job Applicant,Applicant Name,Nama Pemohon
 DocType: Authorization Rule,Customer / Item Name,Nama Pelanggan / Barang
@@ -4410,6 +4720,7 @@
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Serial ada adalah wajib untuk Item {0}
 DocType: Item Variant Attribute,Attribute,Atribut
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Silakan tentukan dari / ke berkisar
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Membuka {0} Faktur dibuat
 DocType: Serial No,Under AMC,Di bawah AMC
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Tingkat penilaian Item dihitung ulang mengingat mendarat biaya jumlah voucher
 apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Pengaturan default untuk menjual transaksi.
@@ -4421,98 +4732,111 @@
 apps/erpnext/erpnext/config/support.py +22,Warranty,Jaminan
 DocType: Purchase Invoice,Debit Note Issued,Debit Note Ditempatkan
 DocType: Production Order,Warehouses,Gudang
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} aset tidak dapat ditransfer
-apps/erpnext/erpnext/stock/doctype/item/item.js +66,This Item is a Variant of {0} (Template).,Item ini adalah Variant dari {0} (Template).
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} aset tidak dapat ditransfer
+apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Item ini adalah Variant dari {0} (Template).
 DocType: Workstation,per hour,per jam
 apps/erpnext/erpnext/config/buying.py +7,Purchasing,pembelian
 DocType: Announcement,Announcement,Pengumuman
-DocType: School Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Untuk Kelompok Siswa berbasis Batch, Student Batch akan divalidasi untuk setiap Siswa dari Program Enrollment."
+DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Untuk Kelompok Siswa berbasis Batch, Student Batch akan divalidasi untuk setiap Siswa dari Program Enrollment."
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Gudang tidak dapat dihapus karena ada entri buku persediaan untuk gudang ini.
-DocType: Company,Distribution,Distribusi
+apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Distribusi
+DocType: Expense Claim Advance,Expense Claim Advance,Klaim Biaya Klaim
 DocType: Lab Test,Report Preference,Preferensi Laporan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +129,Project Manager,Manager Project
+apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Informasi sukarela
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Manager Project
 ,Quoted Item Comparison,Perbandingan Produk/Barang yang ditawarkan
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Tumpang tindih dalam penilaian antara {0} dan {1}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +110,Dispatch,Pengiriman
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Pengiriman
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,Max discount allowed for item: {0} is {1}%,Diskon Max diperbolehkan untuk item: {0} {1}%
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Net Asset value as on,Nilai Aktiva Bersih seperti pada
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Nilai Aktiva Bersih seperti pada
+DocType: Crop,Produce,Menghasilkan
 DocType: Account,Receivable,Piutang
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +288,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Tidak diperbolehkan untuk mengubah Supplier sebagai Purchase Order sudah ada
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Tidak diperbolehkan untuk mengubah Supplier sebagai Purchase Order sudah ada
 DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Peran yang diperbolehkan untuk mengirimkan transaksi yang melebihi batas kredit yang ditetapkan.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +929,Select Items to Manufacture,Pilih Produk untuk Industri
-apps/erpnext/erpnext/accounts/page/pos/pos.js +939,"Master data syncing, it might take some time","Data master sinkronisasi, itu mungkin memakan waktu"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +978,Select Items to Manufacture,Pilih Produk untuk Industri
+DocType: Delivery Stop,Delivery Stop,Berhenti pengiriman
+apps/erpnext/erpnext/accounts/page/pos/pos.js +954,"Master data syncing, it might take some time","Data master sinkronisasi, itu mungkin memakan waktu"
 DocType: Item,Material Issue,Keluar Barang
 DocType: Employee Education,Qualification,Kualifikasi
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +40,View Salary Slips,Lihat Gaji Slip
 DocType: Item Price,Item Price,Item Price
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +48,Soap & Detergent,Sabun & Deterjen
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Sabun & Deterjen
 DocType: BOM,Show Items,Tampilkan Produk
-apps/erpnext/erpnext/schools/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Dari waktu tidak dapat lebih besar dari Untuk Waktu.
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +36,Motion Picture & Video,Motion Picture & Video
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Dari waktu tidak dapat lebih besar dari Untuk Waktu.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +74,Do you want to notify all the customers by email?,Apakah Anda ingin memberi tahu semua pelanggan melalui email?
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Motion Picture & Video
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Ordered
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Lanjut
-DocType: Item Variant Settings,If enabled then system will not update the fields of variants from the template but will copy the data of below mentioned fields while making new variant,Jika diaktifkan maka sistem tidak akan memperbarui bidang varian dari template namun akan menyalin data dari kolom yang disebutkan di bawah sambil membuat varian baru
 DocType: Salary Detail,Component,Komponen
 DocType: Assessment Criteria,Assessment Criteria Group,Kriteria penilaian Grup
 DocType: Healthcare Settings,Patient Name By,Nama Pasien Oleh
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Membuka Penyusutan Akumulasi harus kurang dari sama dengan {0}
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Membuka Penyusutan Akumulasi harus kurang dari sama dengan {0}
 DocType: Warehouse,Warehouse Name,Nama Gudang
 DocType: Naming Series,Select Transaction,Pilih Transaksi
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Entrikan Menyetujui Peran atau Menyetujui Pengguna
 DocType: Journal Entry,Write Off Entry,Menulis Off Entri
 DocType: BOM,Rate Of Materials Based On,Laju Bahan Berbasis On
-DocType: Item Variant Settings,Do not Update Variants,Jangan Perbarui Varian
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Dukungan Analtyics
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +142,Uncheck all,Jangan tandai semua
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Jangan tandai semua
 DocType: POS Profile,Terms and Conditions,Syarat dan Ketentuan
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},Untuk tanggal harus dalam Tahun Anggaran. Dengan asumsi To Date = {0}
 DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Di sini Anda dapat mempertahankan tinggi, berat, alergi, masalah medis dll"
 DocType: Leave Block List,Applies to Company,Berlaku untuk Perusahaan
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +202,Cannot cancel because submitted Stock Entry {0} exists,Tidak bisa membatalkan karena ada Entri Persediaan {0} terkirim
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +222,Cannot cancel because submitted Stock Entry {0} exists,Tidak bisa membatalkan karena ada Entri Persediaan {0} terkirim
 DocType: Employee Loan,Disbursement Date,pencairan Tanggal
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&#39;Penerima&#39; tidak ditentukan
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,'Penerima' belum ditentukan
 DocType: BOM Update Tool,Update latest price in all BOMs,Update harga terbaru di semua BOM
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +40,Medical Record,Rekam medis
 DocType: Vehicle,Vehicle,Kendaraan
 DocType: Purchase Invoice,In Words,Dalam Kata
 apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} harus diserahkan
 DocType: POS Profile,Item Groups,Grup Item
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +217,Today is {0}'s birthday!,Hari ini adalah {0} 's birthday!
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Hari ini adalah {0} 's birthday!
 DocType: Production Planning Tool,Material Request For Warehouse,Permintaan Material Untuk Gudang
 DocType: Sales Order Item,For Production,Untuk Produksi
 DocType: Payment Request,payment_url,payment_url
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +163,Please add a Temporary Opening account in Chart of Accounts,Harap tambahkan akun Pembukaan Sementara di Bagan Akun
+DocType: Customer,Customer Primary Contact,Kontak utama pelanggan
 DocType: Project Task,View Task,Lihat Task
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Peluang/Prospek %
 DocType: Material Request,MREQ-,MREQ-
+DocType: Payment Schedule,Invoice Portion,Bagian faktur
 ,Asset Depreciations and Balances,Penyusutan aset dan Saldo
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +356,Amount {0} {1} transferred from {2} to {3},Jumlah {0} {1} ditransfer dari {2} untuk {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} transferred from {2} to {3},Jumlah {0} {1} ditransfer dari {2} untuk {3}
 DocType: Sales Invoice,Get Advances Received,Dapatkan Uang Muka Diterima
 DocType: Email Digest,Add/Remove Recipients,Tambah / Hapus Penerima
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +461,Transaction not allowed against stopped Production Order {0},Transaksi tidak diperbolehkan berhenti melawan Orde Produksi {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +486,Transaction not allowed against stopped Production Order {0},Transaksi tidak diperbolehkan berhenti melawan Orde Produksi {0}
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Untuk mengatur Tahun Anggaran ini sebagai Default, klik 'Set as Default'"
-apps/erpnext/erpnext/projects/doctype/project/project.py +205,Join,Bergabung
+apps/erpnext/erpnext/projects/doctype/project/project.py +216,Join,Bergabung
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Kekurangan Jumlah
-apps/erpnext/erpnext/stock/doctype/item/item.py +699,Item variant {0} exists with same attributes,Item varian {0} ada dengan atribut yang sama
+apps/erpnext/erpnext/stock/doctype/item/item.py +645,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Tidak dapat mengubah sifat Variant setelah stock transction. Anda harus membuat Item baru untuk melakukan ini.
+apps/erpnext/erpnext/stock/doctype/item/item.py +685,Item variant {0} exists with same attributes,Item varian {0} ada dengan atribut yang sama
 DocType: Employee Loan,Repay from Salary,Membayar dari Gaji
 DocType: Leave Application,LAP/,PUTARAN/
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},Meminta pembayaran terhadap {0} {1} untuk jumlah {2}
 DocType: Salary Slip,Salary Slip,Slip Gaji
 DocType: Lead,Lost Quotation,Quotation hilang
-apps/erpnext/erpnext/utilities/user_progress.py +200,Student Batches,Batch Siswa
+apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Batch Siswa
 DocType: Pricing Rule,Margin Rate or Amount,Tingkat margin atau Jumlah
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,'Sampai Dengan Tanggal' harus diisi
+apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,'Tanggal Akhir' harus diisi
 DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Menghasilkan kemasan slip paket yang akan dikirimkan. Digunakan untuk memberitahu nomor paket, isi paket dan berat."
 DocType: Sales Invoice Item,Sales Order Item,Stok barang Order Penjualan
 DocType: Salary Slip,Payment Days,Hari Jeda Pembayaran
+DocType: Stock Settings,Convert Item Description to Clean HTML,Mengkonversi Deskripsi Item untuk Bersihkan HTML
 DocType: Patient,Dormant,Terbengkalai
+DocType: Salary Slip,Total Interest Amount,Jumlah Bunga Total
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Gudang dengan node anak tidak dapat dikonversi ke buku besar
 DocType: BOM,Manage cost of operations,Kelola biaya operasional
 DocType: Accounts Settings,Stale Days,Hari basi
 DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Ketika salah satu transaksi yang dicentang ""Dikirim"", pop-up email secara otomatis terbuka untuk mengirim email ke ""Kontak"" terkait dalam transaksi itu, dengan transaksi sebagai lampiran. Pengguna bisa mengirim email tersebut atau tidak mengirim."
 apps/erpnext/erpnext/config/setup.py +14,Global Settings,Pengaturan global
+DocType: Crop,Row Spacing UOM,Row Spacing UOM
 DocType: Assessment Result Detail,Assessment Result Detail,Penilaian Detil Hasil
 DocType: Employee Education,Employee Education,Pendidikan Karyawan
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +48,Duplicate item group found in the item group table,Kelompok barang duplikat yang ditemukan dalam tabel grup item
-apps/erpnext/erpnext/public/js/controllers/transaction.js +965,It is needed to fetch Item Details.,Hal ini diperlukan untuk mengambil Item detail.
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Kelompok barang duplikat yang ditemukan dalam tabel grup item
+DocType: Land Unit,Parent Land Unit,Unit Induk Tanah
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1045,It is needed to fetch Item Details.,Hal ini diperlukan untuk mengambil Item detail.
+DocType: Fertilizer,Fertilizer Name,Nama pupuk
 DocType: Salary Slip,Net Pay,Nilai Bersih Terbayar
 DocType: Account,Account,Akun
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serial ada {0} telah diterima
@@ -4520,40 +4844,45 @@
 DocType: Expense Claim,Vehicle Log,kendaraan Log
 DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Adanya demam (suhu&gt; 38,5 ° C / 101,3 ° F atau suhu bertahan&gt; 38 ° C / 100,4 ° F)"
 DocType: Customer,Sales Team Details,Rincian Tim Penjualan
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1326,Delete permanently?,Hapus secara permanen?
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1341,Delete permanently?,Hapus secara permanen?
 DocType: Expense Claim,Total Claimed Amount,Jumlah Total Diklaim
 apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potensi peluang untuk menjadi penjualan.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Valid {0}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Sick Leave,Cuti Sakit
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Cuti Sakit
 DocType: Email Digest,Email Digest,Ringkasan Surel
 DocType: Delivery Note,Billing Address Name,Nama Alamat Penagihan
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +22,Department Stores,Departmen Store
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Departmen Store
 ,Item Delivery Date,Tanggal Pengiriman Barang
 DocType: Warehouse,PIN,PIN
-apps/erpnext/erpnext/setup/setup_wizard/sample_data.py +110,Setup your School in ERPNext,Pengaturan Sekolah Anda di ERPNext
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +125,Error '{0}' occured. Arguments {1}.,Kesalahan &#39;{0}&#39; terjadi. Argumen {1}.
 DocType: Sales Invoice,Base Change Amount (Company Currency),Dasar Nilai Tukar (Mata Uang Perusahaan)
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Tidak ada entri akuntansi untuk gudang berikut
 apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Simpan dokumen terlebih dahulu.
+apps/erpnext/erpnext/shopping_cart/cart.py +71,Only {0} in stock for item {1},Hanya {0} yang tersedia untuk item {1}
 DocType: Account,Chargeable,Dapat Dibebankan
 DocType: Company,Change Abbreviation,Ubah Singkatan
 DocType: Expense Claim Detail,Expense Date,Beban Tanggal
 DocType: Item,Max Discount (%),Max Diskon (%)
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Hari Kredit tidak bisa menjadi angka negatif
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Jumlah Order terakhir
+apps/erpnext/erpnext/stock/doctype/item/item.py +264," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Mempertahankan Sampel didasarkan pada batch, mohon periksa apakah Batch No tidak menyimpan sampel barang"
 DocType: Task,Is Milestone,Adalah tonggak
-DocType: Daily Work Summary,Email Sent To,Surel Dikirim Ke
+DocType: Delivery Stop,Email Sent To,Surel Dikirim Ke
 DocType: Budget,Warn,Peringatan: Cuti aplikasi berisi tanggal blok berikut
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Anda yakin ingin membatalkan pendaftaran?
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Setiap komentar lain, upaya penting yang harus pergi dalam catatan."
-DocType: BOM,Manufacturing User,Manufaktur Pengguna
+DocType: Asset Maintenance,Manufacturing User,Manufaktur Pengguna
 DocType: Purchase Invoice,Raw Materials Supplied,Bahan Baku Disupply
 DocType: C-Form,Series,Seri
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +270,Currency of the price list {0} must be {1} or {2},Mata uang dari daftar harga {0} harus {1} atau {2}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +273,Currency of the price list {0} must be {1} or {2},Mata uang dari daftar harga {0} harus {1} atau {2}
 DocType: Appraisal,Appraisal Template,Template Penilaian
+DocType: Soil Texture,Ternary Plot,Ternary Plot
 DocType: Item Group,Item Classification,Klasifikasi Stok Barang
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +127,Business Development Manager,Business Development Manager
+DocType: Driver,License Number,Nomor lisensi
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Business Development Manager
 DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Pemeliharaan Visit Tujuan
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Pendaftaran Faktur Pasien
-DocType: Drug Prescription,Period,periode
+DocType: Crop,Period,periode
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,General Ledger
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Karyawan {0} pada Cuti pada {1}
 apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Lihat Prospek
@@ -4561,9 +4890,9 @@
 DocType: Item Attribute Value,Attribute Value,Nilai Atribut
 ,Itemwise Recommended Reorder Level,Itemwise Rekomendasi Reorder Tingkat
 DocType: Salary Detail,Salary Detail,Detil gaji
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1017,Please select {0} first,Silahkan pilih {0} terlebih dahulu
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,Silahkan pilih {0} terlebih dahulu
 DocType: Appointment Type,Physician,Dokter
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +804,Batch {0} of Item {1} has expired.,Batch {0} Item {1} telah berakhir.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +833,Batch {0} of Item {1} has expired.,Batch {0} Item {1} telah berakhir.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Konsultasi
 DocType: Sales Invoice,Commission,Komisi
 apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Waktu Lembar untuk manufaktur.
@@ -4574,7 +4903,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Gudang tidak ditemukan dalam sistem
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Ringkasan ini Bulan ini
 DocType: Quality Inspection Reading,Quality Inspection Reading,Nilai Inspeksi Mutu
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +24,`Freeze Stocks Older Than` should be smaller than %d days.,'Bekukan Persediaan Lebih Lama Dari' harus lebih kecil dari %d hari.
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,'Bekukan Persediaan Lebih Lama Dari' harus lebih kecil dari %d hari.
 DocType: Tax Rule,Purchase Tax Template,Pembelian Template Pajak
 apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,Tetapkan sasaran penjualan yang ingin Anda capai untuk perusahaan Anda.
 ,Project wise Stock Tracking,Pelacakan Persediaan menurut Proyek
@@ -4582,42 +4911,50 @@
 apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratorium
 DocType: Stock Entry Detail,Actual Qty (at source/target),Jumlah Aktual (di sumber/target)
 DocType: Item Customer Detail,Ref Code,Ref Kode
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +66,Customer Group is Required in POS Profile,Grup Pelanggan Diperlukan di Profil POS
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +71,Customer Group is Required in POS Profile,Grup Pelanggan Diperlukan di Profil POS
 apps/erpnext/erpnext/config/hr.py +12,Employee records.,Catatan karyawan.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +92,Please set Next Depreciation Date,Silahkan mengatur Berikutnya Penyusutan Tanggal
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +92,Please set Next Depreciation Date,Silahkan mengatur Berikutnya Penyusutan Tanggal
 DocType: HR Settings,Payroll Settings,Pengaturan Payroll
-apps/erpnext/erpnext/config/accounts.py +154,Match non-linked Invoices and Payments.,Cocokkan Faktur non-linked dan Pembayaran.
+apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Cocokkan Faktur non-linked dan Pembayaran.
 DocType: POS Settings,POS Settings,Pengaturan POS
 apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Order
 DocType: Email Digest,New Purchase Orders,Pesanan Pembelian Baru
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Root tidak dapat memiliki pusat biaya orang tua
 apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Pilih Merek ...
+apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Non Profit (beta)
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Acara / Hasil Pelatihan
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Accumulated Depreciation as on,Akumulasi Penyusutan seperti pada
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Akumulasi Penyusutan seperti pada
 DocType: Sales Invoice,C-Form Applicable,C-Form Berlaku
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +399,Operation Time must be greater than 0 for Operation {0},Operasi Waktu harus lebih besar dari 0 untuk operasi {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},Operasi Waktu harus lebih besar dari 0 untuk operasi {0}
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Gudang adalah wajib
 DocType: Supplier,Address and Contacts,Alamat dan Kontak
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Gagal membuat situs web
+DocType: Soil Analysis,Mg/K,Mg / K
 DocType: UOM Conversion Detail,UOM Conversion Detail,Detil UOM Konversi
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +922,Retention Stock Entry already created or Sample Quantity not provided,Entry Stok Retensi sudah dibuat atau Jumlah Sampel tidak disediakan
 DocType: Program,Program Abbreviation,Singkatan Program
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Production Order cannot be raised against a Item Template,Order produksi tidak dapat diajukan terhadap Template Stok Barang
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,Production Order cannot be raised against a Item Template,Order produksi tidak dapat diajukan terhadap Template Stok Barang
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Biaya diperbarui dalam Pembelian Penerimaan terhadap setiap item
 DocType: Warranty Claim,Resolved By,Terselesaikan Dengan
 DocType: Bank Guarantee,Start Date,Tanggal Mulai
 apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Alokasi cuti untuk periode tertentu
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Cek dan Deposit tidak benar dibersihkan
-apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: You can not assign itself as parent account,Akun {0}: Anda tidak dapat menetapkanya sebagai Akun Induk
+apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Akun {0}: Anda tidak dapat menetapkanya sebagai Akun Induk
 DocType: Purchase Invoice Item,Price List Rate,Daftar Harga Tingkat
 apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Buat kutipan pelanggan
 DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Tampilkan ""Tersedia"" atau ""Tidak Tersedia"" berdasarkan persediaan di gudang ini."
 apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Bill of Material (BOM)
 DocType: Item,Average time taken by the supplier to deliver,Rata-rata waktu yang dibutuhkan oleh Supplier untuk memberikan
 DocType: Sample Collection,Collected By,Dikumpulkan Oleh
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,penilaian Hasil
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,penilaian Hasil
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Jam
 DocType: Project,Expected Start Date,Diharapkan Tanggal Mulai
+apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Laporan Detail Variant
 DocType: Setup Progress Action,Setup Progress Action,Setup Progress Action
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +18,Buying Price List,Daftar harga beli
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Hapus item jika biaya ini tidak berlaku untuk item
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Harap pilih Status Pemeliharaan sebagai Selesai atau hapus Tanggal Penyelesaian
+DocType: Supplier,Default Payment Terms Template,Template Persyaratan Pembayaran Default
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Transaksi mata uang harus sama dengan Payment Gateway mata uang
 DocType: Payment Entry,Receive,Menerima
 apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Penawaran:
@@ -4627,20 +4964,20 @@
 DocType: Workstation,Operating Costs,Biaya Operasional
 DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Tindakan jika Akumulasi Anggaran Bulanan Melebihi
 DocType: Subscription,Submit on creation,Kirim pada penciptaan
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +469,Currency for {0} must be {1},Mata uang untuk {0} harus {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +470,Currency for {0} must be {1},Mata uang untuk {0} harus {1}
 DocType: Asset,Disposal Date,pembuangan Tanggal
 DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","Email akan dikirim ke semua Karyawan Aktif perusahaan pada jam tertentu, jika mereka tidak memiliki liburan. Ringkasan tanggapan akan dikirim pada tengah malam."
 DocType: Employee Leave Approver,Employee Leave Approver,Approver Cuti Karyawan
-apps/erpnext/erpnext/stock/doctype/item/item.py +508,Row {0}: An Reorder entry already exists for this warehouse {1},Baris {0}: Entri perekam sudah ada untuk gudang ini {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +485,Row {0}: An Reorder entry already exists for this warehouse {1},Baris {0}: Entri perekam sudah ada untuk gudang ini {1}
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Tidak dapat mendeklarasikan sebagai hilang, karena Quotation telah dibuat."
 apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,pelatihan Masukan
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +458,Production Order {0} must be submitted,Order produksi {0} harus diserahkan
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +483,Production Order {0} must be submitted,Order produksi {0} harus diserahkan
 DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kriteria Scorecard Pemasok
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Silakan pilih Tanggal Mulai dan Tanggal Akhir untuk Item {0}
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Tentu saja adalah wajib berturut-turut {0}
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Tentu saja adalah wajib berturut-turut {0}
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Sampai saat ini tidak dapat sebelumnya dari tanggal
 DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DocType
-apps/erpnext/erpnext/stock/doctype/item/item.js +272,Add / Edit Prices,Tambah / Edit Harga
+apps/erpnext/erpnext/stock/doctype/item/item.js +268,Add / Edit Prices,Tambah / Edit Harga
 DocType: Batch,Parent Batch,Induk induk
 DocType: Cheque Print Template,Cheque Print Template,Template Print Cek
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Bagan Pusat Biaya
@@ -4649,7 +4986,6 @@
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +655,My Orders,Order saya
 DocType: Price List,Price List Name,Daftar Harga Nama
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Ringkasan Pekerjaan sehari-hari untuk {0}
-DocType: Employee Loan,Totals,Total
 DocType: BOM,Manufacturing,Manufaktur
 ,Ordered Items To Be Delivered,Ordered Items Akan Terkirim
 DocType: Account,Income,Penghasilan
@@ -4659,127 +4995,140 @@
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,Faktur Penjualan {0} telah terkirim
 DocType: Supplier Scorecard Scoring Criteria,Score,Skor
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Tahun fiskal {0} tidak ada
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Tanggal Penyelesaian
+DocType: Asset Maintenance Log,Completion Date,Tanggal Penyelesaian
 DocType: Purchase Invoice Item,Amount (Company Currency),Nilai Jumlah (mata uang perusahaan)
+DocType: Crop,Agriculture User,Pengguna pertanian
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Berlaku sampai tanggal tidak dapat dilakukan sebelum tanggal transaksi
-apps/erpnext/erpnext/stock/stock_ledger.py +372,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} unit {1} dibutuhkan dalam {2} pada {3} {4} untuk {5} untuk menyelesaikan transaksi ini.
+apps/erpnext/erpnext/stock/stock_ledger.py +379,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} unit {1} dibutuhkan dalam {2} pada {3} {4} untuk {5} untuk menyelesaikan transaksi ini.
 DocType: Fee Schedule,Student Category,Mahasiswa Kategori
 DocType: Announcement,Student,Mahasiswa
-apps/erpnext/erpnext/config/hr.py +233,Organization unit (department) master.,Unit Organisasi (kawasan) menguasai.
-apps/erpnext/erpnext/utilities/user_progress.py +218,Go to Rooms,Pergi ke kamar
+apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Unit Organisasi (kawasan) menguasai.
+DocType: Shipping Rule,Shipping Rule Type,Jenis aturan pengiriman
+apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Pergi ke kamar
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Entrikan pesan sebelum mengirimnya
 DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLICATE UNTUK PEMASOK
 DocType: Email Digest,Pending Quotations,tertunda Kutipan
-apps/erpnext/erpnext/config/accounts.py +326,Point-of-Sale Profile,Profil Point of Sale
+apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Profil Point of Sale
 apps/erpnext/erpnext/config/healthcare.py +153,Lab Test Configurations.,Konfigurasi Uji Lab
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Pinjaman tanpa Jaminan
 DocType: Cost Center,Cost Center Name,Nama Pusat Biaya
-DocType: Employee,B+,B +
+DocType: Student,B+,B +
 DocType: HR Settings,Max working hours against Timesheet,Max jam bekerja melawan Timesheet
 DocType: Maintenance Schedule Detail,Scheduled Date,Dijadwalkan Tanggal
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77,Total Paid Amt,Total nilai Bayar
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +88,Total Paid Amt,Total nilai Bayar
 DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Pesan lebih dari 160 karakter akan dipecah menjadi beberapa pesan
 DocType: Purchase Receipt Item,Received and Accepted,Diterima dan Diterima
 DocType: Hub Settings,Company and Seller Profile,Profil Perusahaan dan Penjual
 ,GST Itemised Sales Register,Daftar Penjualan Item GST
+DocType: Soil Texture,Silt Loam,Silt Loam
 ,Serial No Service Contract Expiry,Masa Kadaluwarsa Nomor Seri Kontrak Jasa
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Anda tidak dapat mengkredit dan mendebit rekening yang sama secara bersamaan
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +297,You cannot credit and debit same account at the same time,Anda tidak dapat mengkredit dan mendebit rekening yang sama secara bersamaan
 DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Denyut nadi orang dewasa adalah antara 50 dan 80 denyut per menit.
 DocType: Naming Series,Help HTML,Bantuan HTML
 DocType: Student Group Creation Tool,Student Group Creation Tool,Alat Grup Pelajar Creation
 DocType: Item,Variant Based On,Varian Berbasis Pada
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Jumlah weightage ditugaskan harus 100%. Ini adalah {0}
-apps/erpnext/erpnext/utilities/user_progress.py +88,Your Suppliers,Pemasok Anda
+apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,Pemasok Anda
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Perbaiki
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,Tidak dapat ditetapkan sebagai Hilang sebagai Sales Order dibuat.
 DocType: Request for Quotation Item,Supplier Part No,Pemasok Bagian Tidak
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +365,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',tidak bisa memotong ketika kategori adalah untuk &#39;Penilaian&#39; atau &#39;Vaulation dan Total&#39;
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +363,Received From,Diterima dari
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',tidak bisa memotong ketika kategori adalah untuk &#39;Penilaian&#39; atau &#39;Vaulation dan Total&#39;
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Received From,Diterima dari
 DocType: Lead,Converted,Dikonversi
 DocType: Item,Has Serial No,Bernomor Seri
 DocType: Employee,Date of Issue,Tanggal Issue
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +24,{0}: From {0} for {1},{0}: Dari {0} untuk {1}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +219,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Sesuai dengan Setelan Pembelian jika Diperlukan Pembelian Diperlukan == &#39;YA&#39;, maka untuk membuat Purchase Invoice, pengguna harus membuat Purchase Receipt terlebih dahulu untuk item {0}"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +166,Row #{0}: Set Supplier for item {1},Row # {0}: Set Supplier untuk item {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Sesuai dengan Setelan Pembelian jika Diperlukan Pembelian Diperlukan == &#39;YA&#39;, maka untuk membuat Purchase Invoice, pengguna harus membuat Purchase Receipt terlebih dahulu untuk item {0}"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Row # {0}: Set Supplier untuk item {1}
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Row {0}: nilai Jam harus lebih besar dari nol.
-apps/erpnext/erpnext/stock/doctype/item/item.py +183,Website Image {0} attached to Item {1} cannot be found,Website Image {0} melekat Butir {1} tidak dapat ditemukan
+apps/erpnext/erpnext/stock/doctype/item/item.py +185,Website Image {0} attached to Item {1} cannot be found,Website Image {0} melekat Butir {1} tidak dapat ditemukan
 DocType: Issue,Content Type,Tipe Konten
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,Komputer
+DocType: Asset,Assets,Aktiva
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Komputer
 DocType: Item,List this Item in multiple groups on the website.,Daftar Stok Barang ini dalam beberapa kelompok di website.
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82,Please set default customer group and territory in Selling Settings,Harap atur grup pelanggan dan wilayah default di Setelan Penjualan
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,Silakan periksa opsi Mata multi untuk memungkinkan account dengan mata uang lainnya
+DocType: Payment Term,Due Date Based On,Tanggal Jatuh Tempo Berdasarkan
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Harap atur grup pelanggan dan wilayah default di Setelan Penjualan
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +203,{0} {1} does not exist,{0} {1} tidak ada
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +321,Please check Multi Currency option to allow accounts with other currency,Silakan periksa opsi Mata multi untuk memungkinkan account dengan mata uang lainnya
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +85,Item: {0} does not exist in the system,Item: {0} tidak ada dalam sistem
-apps/erpnext/erpnext/accounts/doctype/account/account.py +109,You are not authorized to set Frozen value,Anda tidak diizinkan menetapkan nilai yg sedang dibekukan
+apps/erpnext/erpnext/accounts/doctype/account/account.py +108,You are not authorized to set Frozen value,Anda tidak diizinkan menetapkan nilai yg sedang dibekukan
 DocType: Payment Reconciliation,Get Unreconciled Entries,Dapatkan Entries Unreconciled
 DocType: Payment Reconciliation,From Invoice Date,Dari Faktur Tanggal
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +28,You don't have permission to submit,Anda tidak memiliki izin untuk mengirimkan
-apps/erpnext/erpnext/accounts/party.py +268,Billing currency must be equal to either default comapany's currency or party account currency,Mata uang penagihan harus sama dengan mata uang default atau mata uang akun pihak
 DocType: Healthcare Settings,Laboratory Settings,Pengaturan Laboratorium
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +71,Leave Encashment,Tinggalkan Pencairan
-apps/erpnext/erpnext/public/js/setup_wizard.js +111,What does it do?,Apa pekerjaannya?
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +75,To Warehouse,Untuk Gudang
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +26,All Student Admissions,Semua Penerimaan Mahasiswa
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Tinggalkan Pencairan
+apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Apa pekerjaannya?
+DocType: Crop,Byproducts,Produk sampingan
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +76,To Warehouse,Untuk Gudang
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Semua Penerimaan Mahasiswa
 ,Average Commission Rate,Rata-rata Komisi Tingkat
-apps/erpnext/erpnext/stock/doctype/item/item.py +418,'Has Serial No' can not be 'Yes' for non-stock item,'Bernomor Seri' tidak dapat ‘Ya’ untuk barang non-persediaan
+apps/erpnext/erpnext/stock/doctype/item/item.py +434,'Has Serial No' can not be 'Yes' for non-stock item,'Bernomor Seri' tidak dapat ‘Ya’ untuk barang non-persediaan
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Pilih Status
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Kehadiran tidak dapat ditandai untuk tanggal masa depan
 DocType: Pricing Rule,Pricing Rule Help,Aturan Harga Bantuan
 DocType: School House,House Name,Nama rumah
 DocType: Fee Schedule,Total Amount per Student,Jumlah Total per Siswa
 DocType: Purchase Taxes and Charges,Account Head,Akun Kepala
-apps/erpnext/erpnext/config/stock.py +173,Update additional costs to calculate landed cost of items,Memperbarui biaya tambahan untuk menghitung biaya mendarat item
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +149,Electrical,Listrik
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Listrik
 apps/erpnext/erpnext/utilities/activation.py +100,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Tambahkan sisa organisasi Anda sebagai pengguna Anda. Anda juga dapat menambahkan mengundang Pelanggan portal Anda dengan menambahkan mereka dari Kontak
 DocType: Stock Entry,Total Value Difference (Out - In),Total Nilai Selisih (Out - Dalam)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Row {0}: Kurs adalah wajib
+DocType: Grant Application,Requested Amount,Jumlah yang diminta
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +346,Row {0}: Exchange Rate is mandatory,Row {0}: Kurs adalah wajib
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},User ID tidak ditetapkan untuk Karyawan {0}
 DocType: Vehicle,Vehicle Value,Nilai kendaraan
+DocType: Crop Cycle,Detected Diseases,Penyakit Terdeteksi
 DocType: Stock Entry,Default Source Warehouse,Standar Gudang Sumber
 DocType: Item,Customer Code,Kode Pelanggan
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +216,Birthday Reminder for {0},Birthday Reminder untuk {0}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Birthday Reminder untuk {0}
+DocType: Asset Maintenance Task,Last Completion Date,Tanggal penyelesaian terakhir
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Jumlah Hari Semenjak Order Terakhir
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +355,Debit To account must be a Balance Sheet account,Debit Untuk akun harus rekening Neraca
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +359,Debit To account must be a Balance Sheet account,Debit Untuk akun harus rekening Neraca
 DocType: Buying Settings,Naming Series,Series Penamaan
 DocType: Leave Block List,Leave Block List Name,Cuti Nama Block List
 apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Tanggal asuransi mulai harus kurang dari tanggal asuransi End
-apps/erpnext/erpnext/schools/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in School &gt; School Settings,Silakan setup Sistem Penamaan Instruktur di Sekolah&gt; Pengaturan Sekolah
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Asset Persediaan
 DocType: Timesheet,Production Detail,Detil produksi
 DocType: Restaurant,Active Menu,Menu Aktif
 DocType: Target Detail,Target Qty,Qty Target
 DocType: Shopping Cart Settings,Checkout Settings,Pengaturan Checkout
-DocType: Attendance,Present,ada
+DocType: Student Attendance,Present,ada
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Pengiriman Note {0} tidak boleh Terkirim
 DocType: Notification Control,Sales Invoice Message,Pesan Faktur Penjualan
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Penutupan Rekening {0} harus dari jenis Kewajiban / Ekuitas
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325,Salary Slip of employee {0} already created for time sheet {1},Slip Gaji karyawan {0} sudah dibuat untuk daftar absen {1}
 DocType: Vehicle Log,Odometer,Odometer
 DocType: Sales Order Item,Ordered Qty,Qty Terorder
-apps/erpnext/erpnext/stock/doctype/item/item.py +727,Item {0} is disabled,Item {0} dinonaktifkan
+apps/erpnext/erpnext/stock/doctype/item/item.py +713,Item {0} is disabled,Item {0} dinonaktifkan
 DocType: Stock Settings,Stock Frozen Upto,Stock Frozen Upto
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +904,BOM does not contain any stock item,BOM tidak mengandung barang persediaan
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +929,BOM does not contain any stock item,BOM tidak mengandung barang persediaan
+DocType: Chapter,Chapter Head,Kepala Bab
+DocType: Payment Term,Month(s) after the end of the invoice month,Bulan setelah akhir bulan faktur
 apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Kegiatan proyek / tugas.
 DocType: Vehicle Log,Refuelling Details,Detail Pengisian
 apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Buat Slip Gaji
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"Buying must be checked, if Applicable For is selected as {0}","Membeli harus dicentang, jika ""Berlaku Untuk"" dipilih sebagai {0}"
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Diskon harus kurang dari 100
+DocType: Shipping Rule,Restrict to Countries,Batasi ke Negara
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +171,Select Delivery Notes,Pilih Catatan Pengiriman
 DocType: Purchase Invoice,Write Off Amount (Company Currency),Jumlah Nilai Write Off (mata uang perusahaan)
 DocType: Sales Invoice Timesheet,Billing Hours,Jam penagihan
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +500,Default BOM for {0} not found,BOM default untuk {0} tidak ditemukan
-apps/erpnext/erpnext/stock/doctype/item/item.py +498,Row #{0}: Please set reorder quantity,Row # {0}: Silakan mengatur kuantitas menyusun ulang
+DocType: Project,Total Sales Amount (via Sales Order),Total Jumlah Penjualan (via Sales Order)
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +528,Default BOM for {0} not found,BOM default untuk {0} tidak ditemukan
+apps/erpnext/erpnext/stock/doctype/item/item.py +489,Row #{0}: Please set reorder quantity,Row # {0}: Silakan mengatur kuantitas menyusun ulang
 apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Ketuk item untuk menambahkannya di sini
 DocType: Fees,Program Enrollment,Program Pendaftaran
 DocType: Landed Cost Voucher,Landed Cost Voucher,Voucher Landing Cost
 apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Silakan set {0}
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} adalah siswa tidak aktif
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} adalah siswa tidak aktif
 DocType: Employee,Health Details,Detail Kesehatan
 DocType: Offer Letter,Offer Letter Terms,Term Surat Penawaran
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Untuk membuat dokumen referensi Request Request diperlukan
+DocType: Soil Texture,Sandy Clay,Sandy Clay
+DocType: Grant Application,Assessment  Manager,Manajer Penilaian
 DocType: Payment Entry,Allocate Payment Amount,Alokasikan Jumlah Pembayaran
 DocType: Employee External Work History,Salary,Gaji
 DocType: Serial No,Delivery Document Type,Tipe Nota Pengiriman
-DocType: Process Payroll,Submit all salary slips for the above selected criteria,Menyerahkan semua slip gaji kriteria pilihan di atas
 DocType: Sales Order,Partly Delivered,Terkirim Sebagian
+DocType: Item Variant Settings,Do not update variants on save,Jangan perbarui varian pada save
 DocType: Email Digest,Receivables,Piutang
 DocType: Lead Source,Lead Source,Sumber Prospek
 DocType: Customer,Additional information regarding the customer.,Informasi tambahan mengenai customer.
@@ -4790,24 +5139,27 @@
 DocType: Maintenance Visit,Maintenance Date,Tanggal Pemeliharaan
 DocType: Purchase Invoice Item,Rejected Serial No,Serial No Barang Ditolak
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,Tahun tanggal mulai atau tanggal akhir ini tumpang tindih dengan {0}. Untuk menghindari silakan atur perusahaan
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +94,Please mention the Lead Name in Lead {0},Harap sebutkan Nama Prospek di Prospek {0}
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +108,Please mention the Lead Name in Lead {0},Harap sebutkan Nama Prospek di Prospek {0}
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Tanggal mulai harus kurang dari tanggal akhir untuk Item {0}
 DocType: Item,"Example: ABCD.#####
 If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Contoh:. ABCD ##### 
  Jika seri diatur dan Nomor Seri tidak disebutkan dalam transaksi, maka nomor seri otomatis akan dibuat berdasarkan seri ini. Jika Anda ingin selalu menetapkan Nomor Seri untuk item ini, biarkan kosong."
 DocType: Upload Attendance,Upload Attendance,Unggah Kehadiran
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +319,BOM and Manufacturing Quantity are required,BOM dan Kuantitas Manufaktur wajib diperlukan
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +535,BOM and Manufacturing Quantity are required,BOM dan Kuantitas Manufaktur wajib diperlukan
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Rentang Ageing 2
 DocType: SG Creation Tool Course,Max Strength,Max Kekuatan
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Menginstal preset
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +67,No Delivery Note selected for Customer {},Tidak ada Catatan Pengiriman yang dipilih untuk Pelanggan {}
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,BOM diganti
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +992,Select Items based on Delivery Date,Pilih Item berdasarkan Tanggal Pengiriman
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Select Items based on Delivery Date,Pilih Item berdasarkan Tanggal Pengiriman
+DocType: Grant Application,Has any past Grant Record,Memiliki Record Grant masa lalu
 ,Sales Analytics,Analitika Penjualan
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +119,Available {0},Tersedia {0}
 ,Prospects Engaged But Not Converted,Prospek Terlibat Tapi Tidak Dikonversi
 DocType: Manufacturing Settings,Manufacturing Settings,Pengaturan manufaktur
 apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Mengatur Email
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Ponsel Tidak
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +103,Please enter default currency in Company Master,Entrikan mata uang default di Perusahaan Guru
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Ponsel Tidak
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Entrikan mata uang default di Perusahaan Guru
 DocType: Stock Entry Detail,Stock Entry Detail,Rincian Entri Persediaan
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Pengingat Harian
 DocType: Products Settings,Home Page is Products,Home Page adalah Produk
@@ -4816,17 +5168,17 @@
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,New Account Name
 DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Biaya Bahan Baku Disediakan
 DocType: Selling Settings,Settings for Selling Module,Pengaturan untuk Jual Modul
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +111,Customer Service,Layanan Pelanggan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Layanan Pelanggan
 DocType: BOM,Thumbnail,Kuku ibu jari
 DocType: Item Customer Detail,Item Customer Detail,Rincian Barang Pelanggan
 apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Tawarkan Lowongan Kerja kepada Calon
 DocType: Notification Control,Prompt for Email on Submission of,Minta Email untuk Pengiriman
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Jumlah cuti dialokasikan lebih dari hari pada periode
+DocType: Land Unit,Linked Soil Analysis,Analisis Tanah Terkait
 DocType: Pricing Rule,Percentage,Persentase
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Barang {0} harus barang persediaan
 DocType: Manufacturing Settings,Default Work In Progress Warehouse,Standar Gudang Work In Progress
-apps/erpnext/erpnext/config/accounts.py +296,Default settings for accounting transactions.,Pengaturan default untuk transaksi akuntansi.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +23,Please setup Employee Naming System in Human Resource &gt; HR Settings,Silakan setup Employee Naming System di Human Resource&gt; HR Settings
+apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Pengaturan default untuk transaksi akuntansi.
 DocType: Maintenance Visit,MV,MV
 DocType: Restaurant,Default Tax Template,Template Pajak Default
 DocType: Fees,Student Details,Rincian siswa
@@ -4835,15 +5187,15 @@
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Kesalahan: Tidak id valid?
 DocType: Naming Series,Update Series Number,Pembaruan Series Number
 DocType: Account,Equity,Modal
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: 'Laba Rugi' jenis akun {2} tidak diperbolehkan di Entri Awal
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: jenis akun 'Laba Rugi' {2} tidak diperbolehkan di Entri Awal
 DocType: Sales Order,Printing Details,Detai Print dan Cetak
 DocType: Task,Closing Date,Tanggal Penutupan
 DocType: Sales Order Item,Produced Quantity,Jumlah Diproduksi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +122,Engineer,Insinyur
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Insinyur
 DocType: Journal Entry,Total Amount Currency,Jumlah Total Mata Uang
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Cari Barang Sub Assembly
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +168,Item Code required at Row No {0},Item Code dibutuhkan pada Row ada {0}
-apps/erpnext/erpnext/utilities/user_progress.py +133,Go to Items,Pergi ke item
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Item Code dibutuhkan pada Row ada {0}
+apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Pergi ke item
 DocType: Sales Partner,Partner Type,Tipe Mitra/Partner
 DocType: Purchase Taxes and Charges,Actual,Aktual
 DocType: Restaurant Menu,Restaurant Manager,Manajer restoran
@@ -4860,35 +5212,37 @@
 DocType: Item Reorder,Re-Order Level,Tingkat Re-order
 DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Masukkan item dan rencana jumlah yang Anda inginkan untuk meningkatkan pesanan produksi atau unduh bahan baku untuk analisis.
 apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Gantt Bagan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +95,Part-time,Part-time
+DocType: Crop Cycle,Cycle Type,Tipe siklus
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Part-time
 DocType: Employee,Applicable Holiday List,Daftar Hari Libur yang Berlaku
 DocType: Employee,Cheque,Cek
 DocType: Training Event,Employee Emails,Email Karyawan
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,Seri Diperbarui
-apps/erpnext/erpnext/accounts/doctype/account/account.py +162,Report Type is mandatory,Jenis Laporan adalah wajib
+apps/erpnext/erpnext/accounts/doctype/account/account.py +161,Report Type is mandatory,Jenis Laporan adalah wajib
 DocType: Item,Serial Number Series,Serial Number Series
 apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Gudang adalah wajib untuk persediaan Barang {0} pada baris {1}
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +45,Retail & Wholesale,Retail & Grosir
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Retail & Grosir
 DocType: Issue,First Responded On,Ditangani Pertama kali pada
 DocType: Website Item Group,Cross Listing of Item in multiple groups,Daftar Lintas Item dalam beberapa kelompok
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Tahun Anggaran Tanggal Mulai dan Akhir Tahun Fiskal Tanggal sudah ditetapkan pada Tahun Anggaran {0}
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Cukai Tanggal diperbarui
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +131,Split Batch,Split batch
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +138,Split Batch,Split batch
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Berhasil Direkonsiliasi
 DocType: Request for Quotation Supplier,Download PDF,Unduh PDF
 DocType: Production Order,Planned End Date,Tanggal Akhir Planning
-apps/erpnext/erpnext/controllers/buying_controller.py +423,Please enter Schedule Date,Harap masukkan Jadwal Tanggal
-apps/erpnext/erpnext/config/stock.py +189,Where items are stored.,Dimana Item Disimpan
+apps/erpnext/erpnext/controllers/buying_controller.py +424,Please enter Schedule Date,Harap masukkan Jadwal Tanggal
+apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informasi Jenis Donor.
 DocType: Request for Quotation,Supplier Detail,pemasok Detil
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Kesalahan dalam rumus atau kondisi: {0}
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Nilai Tertagih Faktur
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Kriteria bobot harus menambahkan hingga 100%
-DocType: Attendance,Attendance,Absensi
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Absensi
 apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,Barang Persediaan
 DocType: BOM,Materials,Material/Barang
 DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Jika tidak diperiksa, daftar harus ditambahkan ke setiap departemen di mana itu harus diterapkan."
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Sumber dan Target Gudang tidak bisa sama
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +535,Posting date and posting time is mandatory,Tanggal posting dan posting waktu adalah wajib
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +103,Creating {0},Membuat {0}
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Sumber dan Target Gudang tidak bisa sama
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +561,Posting date and posting time is mandatory,Tanggal posting dan posting waktu adalah wajib
 apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Template pajak untuk membeli transaksi.
 ,Item Prices,Harga Barang/Item
 DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,Dalam Kata-kata akan terlihat setelah Anda menyimpan Purchase Order.
@@ -4898,39 +5252,42 @@
 apps/erpnext/erpnext/config/selling.py +67,Price List master.,List Master Daftar Harga
 DocType: Task,Review Date,Tanggal Ulasan
 DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Seri untuk Entry Depreciation Aset (Entri Jurnal)
+DocType: Membership,Member Since,Anggota Sejak
 DocType: Purchase Invoice,Advance Payments,Uang Muka Pembayaran(Down Payment / Advance)
 DocType: Purchase Taxes and Charges,On Net Total,Pada Jumlah Net Bersih
 apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Nilai untuk Atribut {0} harus berada dalam kisaran {1} ke {2} dalam penambahan {3} untuk Item {4}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,Target warehouse in row {0} must be same as Production Order,Target gudang di baris {0} harus sama dengan Orde Produksi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +166,Target warehouse in row {0} must be same as Production Order,Target gudang di baris {0} harus sama dengan Orde Produksi
 DocType: Restaurant Reservation,Waitlisted,Daftar tunggu
-apps/erpnext/erpnext/accounts/doctype/account/account.py +127,Currency can not be changed after making entries using some other currency,Mata uang tidak dapat diubah setelah melakukan entri menggunakan beberapa mata uang lainnya
+apps/erpnext/erpnext/accounts/doctype/account/account.py +126,Currency can not be changed after making entries using some other currency,Mata uang tidak dapat diubah setelah melakukan entri menggunakan beberapa mata uang lainnya
+DocType: Shipping Rule,Fixed,Tetap
 DocType: Vehicle Service,Clutch Plate,clutch Plat
 DocType: Company,Round Off Account,Akun Pembulatan
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Beban Administrasi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,Konsultasi
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Konsultasi
 DocType: Customer Group,Parent Customer Group,Induk Kelompok Pelanggan
 DocType: Journal Entry,Subscription,Berlangganan
 DocType: Purchase Invoice,Contact Email,Email Kontak
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Penciptaan Biaya Tertunda
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Penciptaan Biaya Tertunda
 DocType: Appraisal Goal,Score Earned,Skor Earned
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +229,Notice Period,Masa Pemberitahuan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Notice Period,Masa Pemberitahuan
 DocType: Asset Category,Asset Category Name,Aset Kategori Nama
 apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Ini adalah wilayah akar dan tidak dapat diedit.
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Nama baru Sales Person
 DocType: Packing Slip,Gross Weight UOM,UOM Berat Kotor
+DocType: Asset Maintenance Task,Preventive Maintenance,Pemeliharaan preventif
 DocType: Delivery Note Item,Against Sales Invoice,Terhadap Faktur Penjualan
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +141,Please enter serial numbers for serialized item ,Harap masukkan nomor seri untuk item serial
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Harap masukkan nomor seri untuk item serial
 DocType: Bin,Reserved Qty for Production,Dicadangkan Jumlah Produksi
 DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Biarkan tidak dicentang jika Anda tidak ingin mempertimbangkan batch sambil membuat kelompok berbasis kursus.
 DocType: Asset,Frequency of Depreciation (Months),Frekuensi Penyusutan (Bulan)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +493,Credit Account,Akun kredit
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +501,Credit Account,Akun kredit
 DocType: Landed Cost Item,Landed Cost Item,Jenis Barang Biaya Landing
 apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Tampilkan nilai nol
 DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Jumlah Kuantitas Produk yang dihasilkan dari proses manufakturing / repacking dari jumlah kuantitas bahan baku yang disediakan
 DocType: Lab Test,Test Group,Grup Uji
 DocType: Payment Reconciliation,Receivable / Payable Account,Piutang / Account Payable
 DocType: Delivery Note Item,Against Sales Order Item,Terhadap Barang di Order Penjualan
-apps/erpnext/erpnext/stock/doctype/item/item.py +694,Please specify Attribute Value for attribute {0},Silakan tentukan Atribut Nilai untuk atribut {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +680,Please specify Attribute Value for attribute {0},Silakan tentukan Atribut Nilai untuk atribut {0}
 DocType: Item,Default Warehouse,Standar Gudang
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Anggaran tidak dapat diberikan terhadap Account Group {0}
 DocType: Healthcare Settings,Patient Registration,Pendaftaran Pasien
@@ -4942,23 +5299,27 @@
 DocType: Appraisal,Total Score (Out of 5),Skor Total (Out of 5)
 DocType: Fee Structure,FS.,FS.
 DocType: Student Attendance Tool,Batch,Batch
+DocType: Donor,Donor Type,Jenis Donor
 apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Keseimbangan
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Silahkan pilih Perusahaan
 DocType: Room,Seating Capacity,Kapasitas tempat duduk
 DocType: Issue,ISS-,ISS-
 DocType: Lab Test Groups,Lab Test Groups,Kelompok Uji Lab
 DocType: Project,Total Expense Claim (via Expense Claims),Jumlah Klaim Beban (via Klaim Beban)
 DocType: GST Settings,GST Summary,Ringkasan GST
 DocType: Assessment Result,Total Score,Skor total
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +116,Please set the Default Cost Center in {0} company,Harap atur Default Cost Center di {0} perusahaan
 DocType: Journal Entry,Debit Note,Debit Note
 DocType: Stock Entry,As per Stock UOM,Sesuai UOM Persediaan
 apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Tidak Kedaluwarsa
 DocType: Student Log,Achievement,Pencapaian
 DocType: Batch,Source Document Type,Jenis Dokumen Sumber
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Jadwal kursus berikut telah dibuat
 DocType: Journal Entry,Total Debit,Jumlah Debit
 DocType: Manufacturing Settings,Default Finished Goods Warehouse,Gudang bawaan Selesai Stok Barang
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +77,Sales Person,Sales Person
-apps/erpnext/erpnext/config/accounts.py +241,Budget and Cost Center,Anggaran dan Pusat Biaya
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +60,Multiple default mode of payment is not allowed,Beberapa modus pembayaran default tidak diperbolehkan
+apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Anggaran dan Pusat Biaya
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Beberapa modus pembayaran default tidak diperbolehkan
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,Untuk
 ,Appointment Analytics,Penunjukan Analytics
 DocType: Vehicle Service,Half Yearly,Setengah Tahunan
@@ -4967,17 +5328,18 @@
 DocType: Healthcare Settings,Consultations in valid days,Konsultasi di hari yang benar
 DocType: Assessment Plan Criteria,Maximum Score,Skor maksimum
 apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Buat aturan untuk membatasi transaksi berdasarkan nilai-nilai.
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,No. Roll Kelompok
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Penciptaan Biaya Gagal
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,No. Roll Kelompok
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Penciptaan Biaya Gagal
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Biarkan kosong jika Anda membuat kelompok siswa per tahun
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Jika dicentang, total ada. dari Hari Kerja akan mencakup libur, dan ini akan mengurangi nilai Gaji Per Hari"
 DocType: Purchase Invoice,Total Advance,Jumlah Uang Muka
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Ubah Kode Template
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Jangka Tanggal Akhir tidak dapat lebih awal dari tanggal Term Start. Perbaiki tanggal dan coba lagi.
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Jangka Tanggal Akhir tidak dapat lebih awal dari tanggal Term Start. Perbaiki tanggal dan coba lagi.
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,"Jumlah ""Penawaran"""
 ,BOM Stock Report,Laporan Persediaan BOM
 DocType: Stock Reconciliation Item,Quantity Difference,Perbedaan Kuantitas
-apps/erpnext/erpnext/config/hr.py +315,Processing Payroll,Pengolahan Payroll
+DocType: Employee Advance,EA-,EA-
+apps/erpnext/erpnext/config/hr.py +320,Processing Payroll,Pengolahan Payroll
 DocType: Opportunity Item,Basic Rate,Harga Dasar
 DocType: GL Entry,Credit Amount,Jumlah kredit
 DocType: Cheque Print Template,Signatory Position,Posisi penandatangan
@@ -4985,7 +5347,7 @@
 DocType: Timesheet,Total Billable Hours,Total Jam Ditagih
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Pembayaran Penerimaan Catatan
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Hal ini didasarkan pada transaksi terhadap pelanggan ini. Lihat timeline di bawah untuk rincian
-DocType: Supplier,Credit Days Based On,Hari Kredit Berdasarkan
+DocType: Company,Credit Days Based On,Hari Kredit Berdasarkan
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Row {0}: Dialokasikan jumlah {1} harus kurang dari atau sama dengan jumlah entri Pembayaran {2}
 ,Course wise Assessment Report,Laporan Penilaian yang tepat
 DocType: Tax Rule,Tax Rule,Aturan pajak
@@ -4993,66 +5355,73 @@
 DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Rencana waktu log luar Jam Kerja Workstation.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +92,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} tidak memiliki Jadwal Dokter. Tambahkan di master dokter
 apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Pelanggan di Antrian
+DocType: Driver,Issuing Date,Tanggal penerbitan
 DocType: Student,Nationality,Kebangsaan
 ,Items To Be Requested,Items Akan Diminta
 DocType: Company,Company Info,Info Perusahaan
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1359,Select or add new customer,Pilih atau menambahkan pelanggan baru
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +154,Cost center is required to book an expense claim,pusat biaya diperlukan untuk memesan klaim biaya
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1374,Select or add new customer,Pilih atau menambahkan pelanggan baru
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +179,Cost center is required to book an expense claim,pusat biaya diperlukan untuk memesan klaim biaya
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Penerapan Dana (Aset)
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Hal ini didasarkan pada kehadiran Karyawan ini
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Mark Kehadiran
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +487,Debit Account,Akun Debit
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Mark Kehadiran
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +495,Debit Account,Akun Debit
 DocType: Fiscal Year,Year Start Date,Tanggal Mulai Tahun
 DocType: Attendance,Employee Name,Nama Karyawan
 DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Item Item Pemesanan Restoran
-DocType: Sales Invoice,Rounded Total (Company Currency),Rounded Jumlah (Perusahaan Mata Uang)
-apps/erpnext/erpnext/accounts/doctype/account/account.py +99,Cannot covert to Group because Account Type is selected.,Tidak dapat mengkonversi ke Grup karena Tipe Akun dipilih.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +240,{0} {1} has been modified. Please refresh.,{0} {1} telah dimodifikasi. Silahkan me-refresh.
+DocType: Purchase Invoice,Rounded Total (Company Currency),Rounded Jumlah (Perusahaan Mata Uang)
+apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Cannot covert to Group because Account Type is selected.,Tidak dapat mengkonversi ke Grup karena Tipe Akun dipilih.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} telah diubah. Silahkan refresh.
 DocType: Leave Block List,Stop users from making Leave Applications on following days.,Menghentikan pengguna dari membuat Aplikasi Leave pada hari-hari berikutnya.
+DocType: Asset Maintenance Team,Maintenance Team Members,Anggota Tim Pemeliharaan
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Jumlah pembelian
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Pemasok Quotation {0} dibuat
 apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Akhir Tahun tidak boleh sebelum Mulai Tahun
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +222,Employee Benefits,Manfaat Karyawan
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Employee Benefits,Manfaat Karyawan
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packed quantity must equal quantity for Item {0} in row {1},Dikemas kuantitas harus sama kuantitas untuk Item {0} berturut-turut {1}
 DocType: Production Order,Manufactured Qty,Qty Diproduksi
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Faktur dibuat
+DocType: Asset,Out of Order,Habis
 DocType: Purchase Receipt Item,Accepted Quantity,Qty Diterima
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Please set a default Holiday List for Employee {0} or Company {1},Silahkan mengatur default Liburan Daftar Karyawan {0} atau Perusahaan {1}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},Silahkan mengatur default Liburan Daftar Karyawan {0} atau Perusahaan {1}
 apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0}: {1} tidak ada
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +75,Select Batch Numbers,Pilih Batch Numbers
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Pilih Batch Numbers
 apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Tagihan diajukan ke Pelanggan.
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Proyek Id
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Row ada {0}: Jumlah dapat tidak lebih besar dari Pending Jumlah terhadap Beban Klaim {1}. Pending Jumlah adalah {2}
-DocType: Maintenance Schedule,Schedule,Jadwal
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +532,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Row ada {0}: Jumlah dapat tidak lebih besar dari Pending Jumlah terhadap Beban Klaim {1}. Pending Jumlah adalah {2}
+DocType: Assessment Plan,Schedule,Jadwal
 DocType: Account,Parent Account,Rekening Induk
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +253,Available,Tersedia
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,Tersedia
 DocType: Quality Inspection Reading,Reading 3,Membaca 3
 ,Hub,Pusat
 DocType: GL Entry,Voucher Type,Voucher Type
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1691,Price List not found or disabled,Daftar Harga tidak ditemukan atau dinonaktifkan
-DocType: Lab Test,Approved,Disetujui
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1706,Price List not found or disabled,Daftar Harga tidak ditemukan atau dinonaktifkan
+DocType: Student Applicant,Approved,Disetujui
 DocType: Pricing Rule,Price,Harga
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',Karyawan lega pada {0} harus ditetapkan sebagai 'Kiri'
 DocType: Hub Settings,Last Sync On,Sinkron Terakhir Aktif
 DocType: Guardian,Guardian,Wali
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Penilaian {0} telah dibuat untuk karyawan {1} dalam rentang tanggal tertentu
-DocType: Employee,Education,Pendidikan
+DocType: Academic Term,Education,Pendidikan
 apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,Del
 DocType: Selling Settings,Campaign Naming By,Penamaan Kampanye Promosi dengan
 DocType: Employee,Current Address Is,Alamat saat ini adalah
 apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Target Penjualan Bulanan
 apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,diubah
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +41,"Optional. Sets company's default currency, if not specified.","Opsional. Set mata uang default perusahaan, jika tidak ditentukan."
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Opsional. Set mata uang default perusahaan, jika tidak ditentukan."
 DocType: Sales Invoice,Customer GSTIN,Pelanggan GSTIN
+DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,Daftar penyakit yang terdeteksi di lapangan. Bila dipilih maka secara otomatis akan menambahkan daftar tugas untuk mengatasi penyakit tersebut
+DocType: Asset Repair,Repair Status,Status perbaikan
 apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Pencatatan Jurnal akuntansi.
 DocType: Delivery Note Item,Available Qty at From Warehouse,Jumlah yang tersedia di Gudang Dari
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,Silakan pilih Rekam Karyawan terlebih dahulu.
 DocType: POS Profile,Account for Change Amount,Akun untuk Perubahan Jumlah
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Row {0}: Partai / Rekening tidak sesuai dengan {1} / {2} di {3} {4}
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kode Kursus:
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +215,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Row {0}: Partai / Rekening tidak sesuai dengan {1} / {2} di {3} {4}
+DocType: Maintenance Team Member,Maintenance Team Member,Anggota Tim Pemeliharaan
+DocType: Agriculture Analysis Criteria,Soil Analysis,Analisis tanah
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kode Kursus:
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,Masukan Entrikan Beban Akun
 DocType: Account,Stock,Persediaan
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1042,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Dokumen Referensi Type harus menjadi salah satu Purchase Order, Faktur Pembelian atau Journal Entri"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Dokumen Referensi Type harus menjadi salah satu Purchase Order, Faktur Pembelian atau Journal Entri"
 DocType: Employee,Current Address,Alamat saat ini
 DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Jika item adalah varian dari item lain maka deskripsi, gambar, harga, pajak dll akan ditetapkan dari template kecuali secara eksplisit ditentukan"
 DocType: Serial No,Purchase / Manufacture Details,Detail Pembelian / Produksi
@@ -5063,53 +5432,52 @@
 DocType: Sales Invoice Item,Discount and Margin,Diskon dan Margin
 DocType: Lab Test,Prescription,Resep
 DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,Tarik Order penjualan (pending untuk memberikan) berdasarkan kriteria di atas
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +90,Not Available,Tidak Tersedia
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Tidak Tersedia
 DocType: Pricing Rule,Min Qty,Min Qty
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Nonaktifkan Template
-DocType: Asset Movement,Transaction Date,Transaction Tanggal
+DocType: GL Entry,Transaction Date,Transaction Tanggal
 DocType: Production Plan Item,Planned Qty,Qty Planning
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total Pajak
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177,For Quantity (Manufactured Qty) is mandatory,Untuk Quantity (Diproduksi Qty) adalah wajib
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +182,For Quantity (Manufactured Qty) is mandatory,Untuk Quantity (Diproduksi Qty) adalah wajib
 DocType: Stock Entry,Default Target Warehouse,Standar Sasaran Gudang
 DocType: Purchase Invoice,Net Total (Company Currency),Jumlah Bersih (Perusahaan Mata Uang)
-apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Akhir Tahun Tanggal tidak dapat lebih awal dari Tahun Tanggal Mulai. Perbaiki tanggal dan coba lagi.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Row {0}: Partai Jenis dan Partai ini hanya berlaku terhadap Piutang / Hutang akun
+apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Akhir Tahun Tanggal tidak dapat lebih awal dari Tahun Tanggal Mulai. Perbaiki tanggal dan coba lagi.
 DocType: Notification Control,Purchase Receipt Message,Pesan Nota Penerimaan
 DocType: BOM,Scrap Items,scrap Produk
 DocType: Production Order,Actual Start Date,Tanggal Mulai Aktual
 DocType: Sales Order,% of materials delivered against this Sales Order,% Dari materi yang Terkirim terhadap Sales Order ini
-apps/erpnext/erpnext/config/stock.py +12,Record item movement.,Rekam Perpindahan Stok Barang
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +57,Set default mode of payment,Tetapkan mode pembayaran default
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Tetapkan mode pembayaran default
+DocType: Grant Application,Withdrawn,pendiam
 DocType: Hub Settings,Hub Settings,Pengaturan Hub
 DocType: Project,Gross Margin %,Gross Margin%
 DocType: BOM,With Operations,Dengan Operasi
-apps/erpnext/erpnext/accounts/party.py +264,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Entri Akuntansi telah dibuat dalam mata uang {0} untuk perusahaan {1}. Silakan pilih akun piutang atau hutang dengan mata uang {0}.
+apps/erpnext/erpnext/accounts/party.py +262,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Entri Akuntansi telah dibuat dalam mata uang {0} untuk perusahaan {1}. Silakan pilih akun piutang atau hutang dengan mata uang {0}.
 DocType: Asset,Is Existing Asset,Apakah ada Asset
 DocType: Salary Detail,Statistical Component,Komponen statistik
 DocType: Warranty Claim,If different than customer address,Jika berbeda dari alamat pelanggan
 DocType: Purchase Invoice,Without Payment of Tax,Tanpa Pembayaran Pajak
 DocType: BOM Operation,BOM Operation,BOM Operation
+apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Pemenuhan
 DocType: Purchase Taxes and Charges,On Previous Row Amount,Pada Sebelumnya Row Jumlah
-DocType: Student,Home Address,Alamat rumah
 DocType: Item,Has Expiry Date,Memiliki Tanggal Kedaluwarsa
-apps/erpnext/erpnext/config/stock.py +111,Item Variant Settings.,Pengaturan Variasi Item.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +249,Transfer Asset,pengalihan Aset
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +269,Transfer Asset,pengalihan Aset
 DocType: POS Profile,POS Profile,POS Profil
 DocType: Training Event,Event Name,Nama acara
 DocType: Physician,Phone (Office),Telepon (Kantor)
-apps/erpnext/erpnext/hooks.py +147,Admission,Penerimaan
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +29,Admissions for {0},Penerimaan untuk {0}
-apps/erpnext/erpnext/config/accounts.py +265,"Seasonality for setting budgets, targets etc.","Musiman untuk menetapkan anggaran, target dll"
+apps/erpnext/erpnext/hooks.py +151,Admission,Penerimaan
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Penerimaan untuk {0}
+apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Musiman untuk menetapkan anggaran, target dll"
 DocType: Supplier Scorecard Scoring Variable,Variable Name,Nama variabel
-apps/erpnext/erpnext/stock/get_item_details.py +147,"Item {0} is a template, please select one of its variants","Item {0} adalah template, silahkan pilih salah satu variannya"
+apps/erpnext/erpnext/stock/get_item_details.py +142,"Item {0} is a template, please select one of its variants","Item {0} adalah template, silahkan pilih salah satu variannya"
 DocType: Asset,Asset Category,Aset Kategori
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Gaji bersih yang belum dapat negatif
 DocType: Assessment Plan,Room,Kamar
 DocType: Purchase Order,Advance Paid,Pembayaran Dimuka (Advance)
 DocType: Item,Item Tax,Pajak Stok Barang
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +843,Material to Supplier,Bahan untuk Supplier
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +384,Excise Invoice,Cukai Faktur
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}% muncul lebih dari sekali
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +868,Material to Supplier,Bahan untuk Supplier
+DocType: Soil Texture,Loamy Sand,Pasir Loamy
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +594,Excise Invoice,Cukai Faktur
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}% muncul lebih dari sekali
 DocType: Expense Claim,Employees Email Id,ID Email Karyawan
 DocType: Employee Attendance Tool,Marked Attendance,Absensi Terdaftar
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Piutang Lancar
@@ -5117,16 +5485,17 @@
 DocType: Patient,A Positive,Positif
 DocType: Program,Program Name,Program Nama
 DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Pertimbangkan Pajak atau Biaya untuk
+DocType: Driver,Driving License Category,Kategori Lisensi Mengemudi
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Qty Aktual wajib diisi
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +80,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} saat ini memiliki {1} posisi Supplier Scorecard, dan Pesanan Pembelian untuk pemasok ini harus dikeluarkan dengan hati-hati."
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} saat ini memiliki posisi Scorecard Pemasok {1}, dan Pesanan Pembelian untuk pemasok ini harus dikeluarkan dengan hati-hati."
+DocType: Asset Maintenance Team,Asset Maintenance Team,Tim Pemeliharaan Aset
 DocType: Employee Loan,Loan Type,Jenis pinjaman
 DocType: Scheduling Tool,Scheduling Tool,Alat penjadwalan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +176,Credit Card,Kartu Kredit
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Kartu Kredit
 DocType: BOM,Item to be manufactured or repacked,Item yang akan diproduksi atau dikemas ulang
-apps/erpnext/erpnext/config/stock.py +184,Default settings for stock transactions.,Pengaturan standar untuk transaksi persediaan.
 DocType: Employee Education,Major/Optional Subjects,Mayor / Opsional Subjek
 DocType: Sales Invoice Item,Drop Ship,Pengiriman Drop Ship
-DocType: Hub Settings,Suspended,Tergantung
+DocType: Driver,Suspended,Tergantung
 DocType: Training Event,Attendees,peserta
 DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Di sini Anda dapat mempertahankan rincian keluarga seperti nama dan pekerjaan orang tua, pasangan dan anak-anak"
 DocType: Academic Term,Term End Date,Istilah Tanggal Akhir
@@ -5135,13 +5504,13 @@
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Dari Mata dan Mata Uang Untuk tidak bisa sama
 DocType: Stock Entry,Repack,Repack
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Anda harus menyimpan formulir sebelum melanjutkan
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +96,Please select the Company first,Silahkan pilih Perusahaan terlebih dahulu
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Silahkan pilih Perusahaan terlebih dahulu
 DocType: Item Attribute,Numeric Values,Nilai numerik
-apps/erpnext/erpnext/public/js/setup_wizard.js +52,Attach Logo,Pasang Logo
+apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Pasang Logo
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +43,Stock Levels,Tingkat Persediaan
 DocType: Customer,Commission Rate,Tingkat Komisi
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Menciptakan {0} scorecard untuk {1} antara:
-apps/erpnext/erpnext/stock/doctype/item/item.js +346,Make Variant,Buat Varian
+apps/erpnext/erpnext/stock/doctype/item/item.js +472,Make Variant,Buat Varian
 apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Blok aplikasi cuti per departemen
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +144,"Payment Type must be one of Receive, Pay and Internal Transfer","Jenis Pembayaran harus menjadi salah satu Menerima, Pay dan Internal Transfer"
 apps/erpnext/erpnext/config/selling.py +179,Analytics,Analytics
@@ -5149,7 +5518,8 @@
 DocType: Vehicle,Model,Model
 DocType: Production Order,Actual Operating Cost,Biaya Operasi Aktual
 DocType: Payment Entry,Cheque/Reference No,Cek / Referensi Tidak ada
-apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root cannot be edited.,Root tidak dapat diedit.
+DocType: Soil Texture,Clay Loam,Clay Loam
+apps/erpnext/erpnext/accounts/doctype/account/account.py +83,Root cannot be edited.,Root tidak dapat diedit.
 DocType: Item,Units of Measure,Satuan ukur
 DocType: Manufacturing Settings,Allow Production on Holidays,Izinkan Produksi di hari libur
 DocType: Sales Order,Customer's Purchase Order Date,Tanggal Order Pembelian Pelanggan
@@ -5162,39 +5532,37 @@
 DocType: Company,Existing Company,Perusahaan yang ada
 DocType: Healthcare Settings,Result Emailed,Hasil Diemailkan
 apps/erpnext/erpnext/controllers/buying_controller.py +84,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Kategori Pajak telah diubah menjadi ""Total"" karena semua barang adalah barang non-persediaan"
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Item Code&gt; Item Group&gt; Brand
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Silakan pilih file csv
 DocType: Student Leave Application,Mark as Present,Tandai sebagai Hadir
 DocType: Supplier Scorecard,Indicator Color,Indikator Warna
 DocType: Purchase Order,To Receive and Bill,Untuk Diterima dan Ditagih
 apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Produk Pilihan
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +132,Designer,Perancang
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Perancang
 apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Syarat dan Ketentuan Template
 DocType: Serial No,Delivery Details,Detail Pengiriman
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +487,Cost Center is required in row {0} in Taxes table for type {1},Biaya Pusat diperlukan dalam baris {0} dalam tabel Pajak untuk tipe {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +491,Cost Center is required in row {0} in Taxes table for type {1},Biaya Pusat diperlukan dalam baris {0} dalam tabel Pajak untuk tipe {1}
 DocType: Program,Program Code,Kode Program
 DocType: Terms and Conditions,Terms and Conditions Help,Syarat dan Ketentuan Bantuan
 ,Item-wise Purchase Register,Stok Barang-bijaksana Pembelian Register
-DocType: Batch,Expiry Date,Tanggal Berakhir
+DocType: Driver,Expiry Date,Tanggal Berakhir
 DocType: Healthcare Settings,Employee name and designation in print,Nama karyawan dan sebutan di cetak
 ,accounts-browser,account-browser
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +351,Please select Category first,Silahkan pilih Kategori terlebih dahulu
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Silahkan pilih Kategori terlebih dahulu
 apps/erpnext/erpnext/config/projects.py +13,Project master.,Master Proyek
 apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Untuk memungkinkan penagihan lebih atau pemesanan lebih, perbarui ""Penyisihan"" di Pengaturan Persediaan atau Barang."
 DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Jangan menunjukkan simbol seperti $ etc sebelah mata uang.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +459, (Half Day),(Setengah Hari)
-DocType: Supplier,Credit Days,Hari Kredit
+DocType: Payment Term,Credit Days,Hari Kredit
 apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Membuat Batch Mahasiswa
 DocType: Fee Schedule,FRQ.,FRQ.
 DocType: Leave Type,Is Carry Forward,Apakah Carry Teruskan
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +815,Get Items from BOM,Dapatkan item dari BOM
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,Get Items from BOM,Dapatkan item dari BOM
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Hari Masa Tenggang
-apps/erpnext/erpnext/controllers/accounts_controller.py +556,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Posting Tanggal harus sama dengan tanggal pembelian {1} aset {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +600,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Posting Tanggal harus sama dengan tanggal pembelian {1} aset {2}
 DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Periksa ini jika Siswa berada di Institute&#39;s Hostel.
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Cukup masukkan Penjualan Pesanan dalam tabel di atas
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +182,Not Submitted Salary Slips,Tidak Dikirim Gaji Slips
 ,Stock Summary,Ringkasan Persediaan
-apps/erpnext/erpnext/config/accounts.py +280,Transfer an asset from one warehouse to another,Mentransfer aset dari satu gudang ke yang lain
+apps/erpnext/erpnext/config/assets.py +50,Transfer an asset from one warehouse to another,Mentransfer aset dari satu gudang ke yang lain
 DocType: Vehicle,Petrol,Bensin
 apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Bill of Material
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Partai Jenis dan Partai diperlukan untuk Piutang / Hutang akun {1}
@@ -5204,9 +5572,9 @@
 DocType: Employee Loan Application,Rate of Interest,Tingkat Tujuan
 DocType: Expense Claim Detail,Sanctioned Amount,Jumlah sanksi
 DocType: GL Entry,Is Opening,Apakah Membuka
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Baris {0}: Debit masuk tidak dapat dihubungkan dengan {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +194,Row {0}: Debit entry can not be linked with a {1},Baris {0}: Debit masuk tidak dapat dihubungkan dengan {1}
 DocType: Journal Entry,Subscription Section,Bagian Langganan
-apps/erpnext/erpnext/accounts/doctype/account/account.py +193,Account {0} does not exist,Akun {0} tidak ada
+apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Account {0} does not exist,Akun {0} tidak ada
 DocType: Training Event,Training Program,Program pelatihan
 DocType: Account,Cash,Kas
 DocType: Employee,Short biography for website and other publications.,Biografi singkat untuk website dan publikasi lainnya.
