apps/erpnext/erpnext/accounts/doctype/account/account.js +27,This is a root account and cannot be edited.,Ini adalah account root dan tidak dapat diedit.
apps/erpnext/erpnext/accounts/doctype/account/account.js +50,Chart of Accounts,Chart of Account
apps/erpnext/erpnext/accounts/doctype/account/account.js +54,Convert to Ledger,Convert to Ledger
apps/erpnext/erpnext/accounts/doctype/account/account.js +57,View Ledger,View Ledger
apps/erpnext/erpnext/accounts/doctype/account/account.js +67,Convert to Group,Konversikan ke Grup
apps/erpnext/erpnext/accounts/doctype/account/account.js +8,Please create new account from Chart of Accounts.,Silahkan buat akun baru dari Bagan Akun.
apps/erpnext/erpnext/accounts/doctype/account/account.py +105,Report Type is mandatory,Jenis Laporan adalah wajib
apps/erpnext/erpnext/accounts/doctype/account/account.py +108,Root Type is mandatory,Akar Type adalah wajib
apps/erpnext/erpnext/accounts/doctype/account/account.py +116,Warehouse is mandatory if account type is Warehouse,
apps/erpnext/erpnext/accounts/doctype/account/account.py +127,"Stock entries exist against warehouse {0}, hence you cannot re-assign or modify Warehouse",
apps/erpnext/erpnext/accounts/doctype/account/account.py +141,Root account can not be deleted,Account root tidak bisa dihapus
apps/erpnext/erpnext/accounts/doctype/account/account.py +144,Account with existing transaction can not be deleted,Akun dengan transaksi yang ada tidak dapat dihapus
apps/erpnext/erpnext/accounts/doctype/account/account.py +146,Child account exists for this account. You can not delete this account.,Akun anak ada untuk akun ini. Anda tidak dapat menghapus akun ini.
apps/erpnext/erpnext/accounts/doctype/account/account.py +160,Account {0} does not exist,Akun {0} tidak ada
apps/erpnext/erpnext/accounts/doctype/account/account.py +166,"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company","Penggabungan hanya mungkin jika sifat berikut sama di kedua catatan. Grup atau Ledger, Akar Type, Perusahaan"
apps/erpnext/erpnext/accounts/doctype/account/account.py +37,Account {0}: Parent account {1} does not exist,Akun {0}: akun Induk {1} tidak ada
apps/erpnext/erpnext/accounts/doctype/account/account.py +39,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 +41,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 +43,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 +55,Root cannot be edited.,Root tidak dapat diedit.
apps/erpnext/erpnext/accounts/doctype/account/account.py +63,You are not authorized to set Frozen value,Anda tidak diizinkan untuk menetapkan nilai yg sedang dibekukan
apps/erpnext/erpnext/accounts/doctype/account/account.py +71,"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/accounts/doctype/account/account.py +73,"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 +77,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 +79,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 +87,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 +89,Cannot covert to Group because Account Type is selected.,
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +10,Accounts Receivable,Piutang
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +100,Miscellaneous Expenses,Beban lain-lain
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +103,Office Maintenance Expenses,Beban Pemeliharaan Kantor
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +106,Office Rent,Kantor Sewa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +109,Postal Expenses,Beban pos
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +11,Debtors,
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +112,Print and Stationary,Cetak dan Alat Tulis
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +115,Rounded Off,Rounded Off
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +118,Salary,Gaji
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +121,Sales Expenses,Beban Penjualan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +124,Telephone Expenses,Beban Telepon
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +127,Travel Expenses,Biaya Perjalanan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +130,Utility Expenses,Beban utilitas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +137,Income,Penghasilan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +138,Direct Income,Penghasilan Langsung
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +139,Sales,Penjualan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +142,Service,Layanan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +147,Indirect Income,Penghasilan tidak langsung
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +15,Bank Accounts,Rekening Bank
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +153,Source of Funds (Liabilities),Sumber Dana (Kewajiban)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +154,Capital Account,Transaksi Modal
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +155,Reserves and Surplus,Cadangan dan Surplus
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +156,Shareholders Funds,Pemegang Saham Dana
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +158,Current Liabilities,Kewajiban Lancar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +159,Accounts Payable,Hutang
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +160,Creditors,
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +164,Stock Liabilities,Kewajiban saham
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +165,Stock Received But Not Billed,Stock Diterima Tapi Tidak Ditagih
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +169,Duties and Taxes,Tugas dan Pajak
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +173,Loans (Liabilities),Kredit (Kewajiban)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +174,Secured Loans,Pinjaman Aman
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +175,Unsecured Loans,Pinjaman Tanpa Jaminan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +176,Bank Overdraft Account,Cerukan Bank Akun
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +179,Temporary Accounts (Liabilities),Akun Sementara (Kewajiban)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +180,Temporary Liabilities,Kewajiban Sementara
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +19,Cash In Hand,Cash In Hand
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +20,Cash,kas
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +25,Loans and Advances (Assets),Pinjaman Uang Muka dan (Aset)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +26,Securities and Deposits,Efek dan Deposit
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +27,Earnest Money,Uang Earnest
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +29,Stock Assets,Aset saham
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +33,Tax Assets,Aset pajak
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +37,Fixed Assets,Aktiva Tetap
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +38,Capital Equipments,Peralatan Modal
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +41,Computers,Komputer
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +44,Furniture and Fixture,Furniture dan Fixture
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +47,Office Equipments,Peralatan Kantor
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +50,Plant and Machinery,Tanaman dan Mesin
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +54,Investments,Investasi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +57,Temporary Accounts (Assets),Akun Sementara (Aset)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +58,Temporary Assets,Aset Temporary
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +62,Expenses,Beban
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +63,Direct Expenses,Beban Langsung
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +64,Stock Expenses,Beban saham
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +65,Cost of Goods Sold,Harga Pokok Penjualan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +68,Expenses Included In Valuation,Biaya Termasuk Dalam Penilaian
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +71,Stock Adjustment,Penyesuaian Stock
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +78,Indirect Expenses,Biaya tidak langsung
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +79,Administrative Expenses,Beban Administrasi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +8,Application of Funds (Assets),Penerapan Dana (Aset)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +82,Commission on Sales,Komisi Penjualan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +85,Depreciation,Penyusutan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +88,Entertainment Expenses,Beban Hiburan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +9,Current Assets,Aset Lancar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +91,Freight and Forwarding Charges,Pengangkutan dan Forwarding Biaya
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +94,Legal Expenses,Beban Legal
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/standard_chart_of_accounts.py +97,Marketing Expenses,Beban Pemasaran
apps/erpnext/erpnext/accounts/doctype/accounts_settings/accounts_settings.py +25,Company is missing in warehouses {0},Perusahaan hilang di gudang {0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.js +6,Update clearance date of Journal Entries marked as 'Bank Vouchers',Tanggal pembaruan clearance Entries Journal ditandai sebagai 'Bank Voucher'
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +51,Clearance date cannot be before check date in row {0},Tanggal clearance tidak bisa sebelum tanggal check-in baris {0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +61,Clearance Date not mentioned,Izin Tanggal tidak disebutkan
apps/erpnext/erpnext/accounts/doctype/budget_distribution/budget_distribution.py +25,Percentage Allocation should be equal to 100%,Persentase Alokasi harus sama dengan 100%
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Masukkan minimal 1 faktur dalam tabel
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,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/accounts/doctype/cost_center/cost_center.js +54,Chart of Cost Centers,Bagan Pusat Biaya
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +60,Please enter company name first,Silahkan masukkan nama perusahaan pertama
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +20,Please select Group or Ledger value,Silahkan pilih Grup atau Ledger nilai
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +23,Please enter parent cost center,Masukkan pusat biaya orang tua
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +25,Root cannot have a parent cost center,Root tidak dapat memiliki pusat biaya orang tua
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +29,Cannot convert Cost Center to ledger as it has child nodes,Tidak dapat mengkonversi Biaya Center untuk buku karena memiliki node anak
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +31,Cost Center with existing transactions can not be converted to ledger,Biaya Center dengan transaksi yang ada tidak dapat dikonversi ke buku
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +39,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/cost_center/cost_center.py +56,Budget cannot be set for Group Cost Centers,Anggaran tidak dapat ditetapkan untuk Cost Centernya Grup
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +59,Account {0} has been entered more than once for fiscal year {1},Akun {0} telah dimasukkan lebih dari sekali untuk tahun fiskal {1}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +17,Set as Default,Set sebagai Default
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/accounts/doctype/fiscal_year/fiscal_year.py +21,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} sekarang default Tahun Anggaran. Silahkan refresh browser Anda untuk perubahan untuk mengambil efek.
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +29,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Tidak dapat mengubah Tahun Anggaran Tanggal Mulai dan Tanggal Akhir Tahun Anggaran setelah Tahun Anggaran disimpan.
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,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
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +37,Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Tahun Fiskal Tanggal Mulai dan Akhir Tahun Fiskal Tanggal tidak bisa lebih dari satu tahun terpisah.
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +46,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/gl_entry/gl_entry.py +101,Balance for Account {0} must always be {1},Saldo Rekening {0} harus selalu {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +114,You are not authorized to add or update entries before {0},Anda tidak diizinkan untuk menambah atau memperbarui entri sebelum {0}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +134,Against Journal Voucher {0} is already adjusted against some other voucher,
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +143,Outstanding for {0} cannot be less than zero ({1}),Posisi untuk {0} tidak bisa kurang dari nol ({1})
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +157,Account {0} is frozen,Akun {0} dibekukan
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +159,Not authorized to edit frozen Account {0},Tidak berwenang untuk mengedit Akun frozen {0}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +37,{0} is required,{0} diperlukan
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +41,Party Type and Party is required for Receivable / Payable account {0},
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +45,Either debit or credit amount is required for {0},Entah debit atau jumlah kredit diperlukan untuk {0}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +50,Cost Center is required for 'Profit and Loss' account {0},Biaya Pusat diperlukan untuk akun 'Laba Rugi' {0}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,'Profit and Loss' type account {0} not allowed in Opening Entry,'Laba Rugi' jenis account {0} tidak diperbolehkan dalam Pembukaan Entri
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +70,Account {0} cannot be a Group,Akun {0} tidak dapat menjadi akun Grup
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +73,Account {0} is inactive,Akun {0} tidak aktif
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +76,Account {0} does not belong to Company {1},Akun {0} bukan milik Perusahaan {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +90,Cost Center {0} does not belong to Company {1},Biaya Pusat {0} bukan milik Perusahaan {1}
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.js +219,Journal Voucher,Journal Voucher
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.js +86,Cr,
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.js +86,Dr,
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +103,Reference No & Reference Date is required for {0},Referensi ada & Referensi Tanggal diperlukan untuk {0}
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +107,Reference No is mandatory if you entered Reference Date,Referensi ada adalah wajib jika Anda memasukkan Referensi Tanggal
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +115,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +117,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +124,"For {0}, only credit entries can be linked against another debit entry",
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +127,"For {0}, only debit entries can be linked against another credit entry",
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +131,You can not enter current voucher in 'Against Journal Voucher' column,Anda tidak bisa masuk voucher saat ini di 'Melawan Journal Voucher' kolom
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +139,Journal Voucher {0} does not have account {1} or already matched against other voucher,
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +148,Against Journal Voucher {0} does not have any unmatched {1} entry,Terhadap Journal Voucher {0} tidak memiliki {1} perbedaan pencatatan
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +180,Row {0}: Debit entry can not be linked with a {1},
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +183,Row {0}: Credit entry can not be linked with a {1},
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +190,"Row {0}: Party / Account does not match with \
							Customer / Debit To in {1}",
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +197,Row {0}: {1} {2} does not match with {3},
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +210,{0} {1} is not submitted,{0} {1} tidak disampaikan
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +213,"Payment against {0} {1} cannot be greater \
					than Outstanding Amount {2}",
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +225,{0} {1} is fully billed,
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +228,{0} {1} is stopped,
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +231,"Advance paid against {0} {1} cannot be greater \
					than Grand Total {2}",
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +249,You cannot credit and debit same account at the same time,Anda tidak dapat kredit dan mendebit rekening yang sama pada waktu yang sama
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +258,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/accounts/doctype/journal_voucher/journal_voucher.py +265,Reference #{0} dated {1},Referensi # {0} tanggal {1}
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +267,Please enter Reference date,Harap masukkan tanggal Referensi
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +273,{0} against Sales Invoice {1},
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +278,{0} against Sales Order {1},
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +286,{0} against Bill {1} dated {2},
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +291,{0} against Purchase Order {1},
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +295,Note: {0},Catatan: {0}
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +308,Aging Date is mandatory for opening entry,Penuaan Tanggal adalah wajib untuk membuka entri
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +360,'Entries' cannot be empty,'Entries' tidak boleh kosong
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +71,Row{0}: Party Type and Party is required for Receivable / Payable account {1},
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +73,Row{0}: Party Type and Party is only applicable against Receivable / Payable account,
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher.py +97,Note: Reference Date exceeds allowed credit days by {0} days for {1} {2},
apps/erpnext/erpnext/accounts/doctype/journal_voucher/journal_voucher_list.html +13,Draft,Konsep
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +20,Please select Company and Party Type first,
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +35,Please select Company first,
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Successfully Reconciled,Berhasil Berdamai
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,Please select {0} first,Silahkan pilih {0} pertama
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +172,No records found in the Invoice table,Tidak ada catatan yang ditemukan dalam tabel Faktur
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +175,No records found in the Payment table,Tidak ada catatan yang ditemukan dalam tabel Pembayaran
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +187,{0}: {1} not found in Invoice Details table,{0}: {1} tidak ditemukan dalam Faktur Rincian table
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +191,Row {0}: Allocated amount {1} must be less than or equals to JV amount {2},
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +195,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +199,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row",
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +121,"Against Voucher Type must be one of Sales Order, Sales Invoice or Journal Voucher",
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +127,"Against Voucher Type must be one of Purchase Order, Purchase Invoice or Journal Voucher",
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +168,Row {0}: Payment amount can not be negative,
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +170,Row {0}: Payment Amount cannot be greater than Outstanding Amount,
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +9,"Note: If payment is not made against any reference, make Journal Voucher manually.",
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +30,Please enter Payment Amount in atleast one row,
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +34,Row {0}: {1} is not a valid {2},
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +61,No permission to use Payment Tool,
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +70,Please enter the Against Vouchers manually,
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +25,Closing Account {0} must be of type 'Liability',Menutup Akun {0} harus bertipe 'Kewajiban'
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +35,Another Period Closing Entry {0} has been made after {1},Lain Periode Pendaftaran penutupan {0} telah dibuat setelah {1}
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +23,POS Setting {0} already created for user: {1} and company {2},Pengaturan POS {0} sudah diciptakan untuk pengguna: {1} dan perusahaan {2}
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +26,Global POS Setting {0} already created for company {1},Pengaturan POS global {0} sudah dibuat untuk perusahaan {1}
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +32,Expense Account is mandatory,Beban Rekening wajib
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +43,{0} does not belong to Company {1},{0} bukan milik Perusahaan {1}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +12,"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."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +15,"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 Rule 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, itu akan diambil di lapangan 'Tingkat', daripada bidang 'Daftar Harga Tingkat'."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +18,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.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +21,"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."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +27,How Pricing Rule is applied?,Bagaimana Rule Harga diterapkan?
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +31,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Rule harga pertama dipilih berdasarkan 'Terapkan On' lapangan, yang dapat Barang, Barang Grup atau Merek."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +34,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Kemudian Pricing Aturan disaring berdasarkan Pelanggan, Kelompok Pelanggan, Wilayah, Supplier, Supplier Type, Kampanye, Penjualan Mitra dll"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +37,Pricing Rules are further filtered based on quantity.,Aturan harga selanjutnya disaring berdasarkan kuantitas.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +40,"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 didahulukan jika ada beberapa Aturan Harga dengan kondisi yang sama."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +43,"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/accounts/doctype/pricing_rule/pricing_rule.js +46,Item Code > Item Group > Brand,Item Code> Barang Grup> Merek
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +49,Customer > Customer Group > Territory,Pelanggan> Grup Pelanggan> Wilayah
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +52,Supplier > Supplier Type,Pemasok> Pemasok Type
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +57,"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/accounts/doctype/pricing_rule/pricing_rule.js +8,Notes,Catatan
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +135,Item Group not mentioned in item master for item {0},Item Grup tidak disebutkan dalam master barang untuk item {0}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +237,"Multiple Price Rule exists with same criteria, please resolve \
			conflict by assigning priority. Price Rules: {0}",
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +33,Atleast one of the Selling or Buying must be selected,"Setidaknya salah satu, Jual atau Beli harus dipilih"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,"Selling must be checked, if Applicable For is selected as {0}","Jual harus diperiksa, jika Berlaku Untuk dipilih sebagai {0}"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Buying must be checked, if Applicable For is selected as {0}","Membeli harus dicentang, jika ""Berlaku Untuk"" dipilih sebagai {0}"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,Min Qty can not be greater than Max Qty,Min Qty tidak dapat lebih besar dari Max Qty
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +64,{0} can not be negative,{0} tidak dapat negatif
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +70,Max discount allowed for item: {0} is {1}%,Diskon Max diperbolehkan untuk item: {0} {1}%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +238,Purchase Invoice,Purchase Invoice
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +30,Make Payment Entry,Membuat Entri Pembayaran
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +47,From Purchase Order,Dari Purchase Order
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +62,From Purchase Receipt,Dari Penerimaan Pembelian
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +107,Purchase Order {0} is 'Stopped',Pesanan Pembelian {0} 'Berhenti'
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +152,Ageing date is mandatory for opening entry,Penuaan saat ini adalah wajib untuk membuka entri
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +174,Expense account is mandatory for item {0},Rekening pengeluaran adalah wajib untuk item {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +186,Purchse Order number required for Item {0},Nomor pesanan purchse diperlukan untuk Item {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +192,Purchase Receipt number required for Item {0},Nomor Penerimaan Pembelian diperlukan untuk Item {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +196,Please enter Write Off Account,Cukup masukkan Write Off Akun
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +203,Purchase Order {0} is not submitted,Purchase Order {0} tidak disampaikan
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +207,Purchase Receipt {0} is not submitted,Penerimaan Pembelian {0} tidak disampaikan
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +296,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 +64,Against Supplier Invoice {0} dated {1},
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +66,No Remarks,
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +84,Item {0} is not Purchase Item,Item {0} tidak Pembelian Barang
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +89,Please enter default currency in Company Master,Masukkan mata uang default di Perusahaan Guru
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +91,Conversion rate cannot be 0 or 1,Tingkat konversi tidak bisa 0 atau 1
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +96,Credit To account must be a liability account,
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +98,Credit To account must be a Payable account,
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.html +14,Overdue: ,
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.html +19,Payment Pending,
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.html +27,Paid,
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.html +37,Outstanding Amount,Jumlah yang luar biasa
apps/erpnext/erpnext/accounts/doctype/purchase_taxes_and_charges_master/purchase_taxes_and_charges_master.js +102,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for valuation. You can select only 'Total' option for previous row amount or previous row total,Tidak bisa memilih jenis biaya sebagai 'Pada Row Sebelumnya Jumlah' atau 'On Sebelumnya Row Jumlah' untuk penilaian. Anda dapat memilih hanya 'Jumlah' pilihan untuk jumlah baris sebelumnya atau total baris sebelumnya
apps/erpnext/erpnext/accounts/doctype/purchase_taxes_and_charges_master/purchase_taxes_and_charges_master.js +119,Please select charge type first,Silakan pilih jenis charge pertama
apps/erpnext/erpnext/accounts/doctype/purchase_taxes_and_charges_master/purchase_taxes_and_charges_master.js +123,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/purchase_taxes_and_charges_master/purchase_taxes_and_charges_master.js +128,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
apps/erpnext/erpnext/accounts/doctype/purchase_taxes_and_charges_master/purchase_taxes_and_charges_master.js +159,Please select Charge Type first,Silakan pilih Mengisi Tipe pertama
apps/erpnext/erpnext/accounts/doctype/purchase_taxes_and_charges_master/purchase_taxes_and_charges_master.js +174,"Cannot directly set amount. For 'Actual' charge type, use the rate field","Tidak bisa langsung menetapkan jumlah. Untuk 'sebenarnya' jenis biaya, menggunakan kolom tingkat"
apps/erpnext/erpnext/accounts/doctype/purchase_taxes_and_charges_master/purchase_taxes_and_charges_master.js +81,Please select Category first,Silahkan pilih Kategori pertama
apps/erpnext/erpnext/accounts/doctype/purchase_taxes_and_charges_master/purchase_taxes_and_charges_master.js +85,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_taxes_and_charges_master/purchase_taxes_and_charges_master.js +98,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 pertama
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +22,Item,Barang
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +277,Please select {0} first.,Silahkan pilih {0} pertama.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +38,Net Total,Jumlah Bersih
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +400,Stock: ,
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +414,Projected Qty,Proyeksi Jumlah
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +47,Taxes,PPN
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +536,Invalid Barcode,Barcode valid
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +577,Payment cannot be made for empty cart,Pembayaran tidak dapat dibuat untuk keranjang kosong
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +58,Discount Amount,Jumlah Diskon
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +583,Please add to Modes of Payment from Setup.,Silahkan menambah Mode Pembayaran dari Setup.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +70,Grand Total,Grand Total
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +79,Amount Paid,Jumlah Dibayar
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +91,Make Payment,Lakukan Pembayaran
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.js +95,Del,Del
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +48,Invalid Barcode or Serial No,Barcode valid atau Serial No
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +111,From Delivery Note,Dari Delivery Note
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +139,Please specify Company to proceed,Silahkan tentukan Perusahaan untuk melanjutkan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +66,Send SMS,Kirim SMS
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +77,Make Delivery,Membuat Pengiriman
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +94,From Sales Order,Dari Sales Order
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +166,Time Log Batch {0} must be 'Submitted',Waktu Log Batch {0} harus 'Dikirim'
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +246,Debit To account must be a liability account,
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +248,Debit To account must be a Receivable account,
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +258,Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Akun {0} harus bertipe 'Aset Tetap' dikarenakan Barang {1} adalah merupakan sebuah Aset Tetap
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +294,Ageing Date is mandatory for opening entry,Periodisasi Tanggal adalah wajib untuk membuka entri
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +317,{0} is mandatory for Item {1},{0} adalah wajib untuk Item {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +327,Customer {0} does not belong to project {1},Pelanggan {0} bukan milik proyek {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +331,Cash or Bank Account is mandatory for making payment entry,Kas atau Rekening Bank wajib untuk membuat entri pembayaran
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +335,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/accounts/doctype/sales_invoice/sales_invoice.py +341,Item Code required at Row No {0},Item Code dibutuhkan pada Row ada {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +346,Stock cannot be updated against Delivery Note {0},Stock tidak dapat diperbarui terhadap Delivery Note {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365,Please remove this Invoice {0} from C-Form {1},
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +392,POS Setting required to make POS Entry,Pengaturan POS diperlukan untuk membuat POS Entri
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +419,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/accounts/doctype/sales_invoice/sales_invoice.py +429,Sales Order {0} is not submitted,Sales Order {0} tidak disampaikan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +435,Delivery Note {0} is not submitted,Pengiriman Note {0} tidak disampaikan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585,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/accounts/doctype/shipping_rule/shipping_rule.py +38,From value must be less than to value in row {0},Dari nilai harus kurang dari nilai dalam baris {0}
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +42,"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 +75,Overlapping conditions found between:,Kondisi Tumpang Tindih ditemukan antara:
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +79,and,Dan
apps/erpnext/erpnext/accounts/general_ledger.py +100,Account: {0} can only be updated via Stock Transactions,
apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Jumlah yang salah dari General Ledger Entries ditemukan. Anda mungkin telah memilih Account salah dalam transaksi.
apps/erpnext/erpnext/accounts/general_ledger.py +91,Debit and Credit not equal for this voucher. Difference is {0}.,Debit dan Kredit tidak sama untuk voucher ini. Perbedaan adalah {0}.
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +118,Open,Buka
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +126,Add Child,Tambah Anak
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +154,Rename,Ubah nama
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +163,Delete,Hapus
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +185,New Account,Akun baru
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +187,New Account Name,New Account Name
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +188,"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Nama Akun baru. Catatan: Tolong jangan membuat account untuk Pelanggan dan Pemasok, mereka dibuat secara otomatis dari Nasabah dan Pemasok utama"
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +189,Group or Ledger,Grup atau Ledger
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +190,"Further accounts can be made under Groups, but entries can be made against Ledger","Rekening lebih lanjut dapat dibuat di bawah Grup, namun entri dapat dilakukan terhadap Ledger"
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +191,Account Type,Jenis Account
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +195,Optional. This setting will be used to filter in various transactions.,Opsional. Pengaturan ini akan digunakan untuk menyaring dalam berbagai transaksi.
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +196,Tax Rate,Tarif Pajak
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +197,Create New,Buat New
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +23,Quick Help,Bantuan Cepat
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +25,"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Untuk menambahkan node anak, mengeksplorasi pohon dan klik pada node di mana Anda ingin menambahkan lebih banyak node."
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +262,New Cost Center,Biaya Pusat baru
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +264,New Cost Center Name,Baru Nama Biaya Pusat
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +266,Further accounts can be made under Groups but entries can be made against Ledger,Rekening lebih lanjut dapat dibuat di bawah Grup tetapi entri dapat dilakukan terhadap Ledger
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +27,"Accounting Entries can be made against leaf nodes, called","Entri Akuntansi dapat dilakukan terhadap node daun, yang disebut"
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +28,Entries against ,Entries against 
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +28,Ledgers,Buku Pembantu
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +29,Groups,Grup
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +29,are not allowed.,tidak diperbolehkan.
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +31,Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Mohon TIDAK membuat Account (Buku Pembantu) untuk Pelanggan dan Pemasok. Mereka diciptakan langsung dari Nasabah / Pemasok master.
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +33,To create a Bank Account,Untuk membuat Rekening Bank
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +34,"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account Ledger (by clicking on Add Child) of type ""Bank""","Pergi ke grup yang sesuai (biasanya Penerapan Dana> Aset Lancar> Rekening Bank dan membuat Akun baru Ledger (dengan mengklik Tambahkan Child) tipe ""Bank"""
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +37,To create a Tax Account,Untuk membuat Akun Pajak
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +38,"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account Ledger (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.","Pergi ke grup yang sesuai (biasanya Sumber Dana> Kewajiban Lancar> Pajak dan Bea dan membuat Akun baru Ledger (dengan mengklik Tambahkan Child) tipe ""Pajak"" dan jangan menyebutkan tingkat pajak."
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +41,Please setup your chart of accounts before you start Accounting Entries,Silakan pengaturan grafik Anda account sebelum Anda mulai Entries Akuntansi
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +44,New Company,Perusahaan Baru
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +48,Refresh,Segarkan
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +20,PL or BS,PL atau BS
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +21,Profit and Loss,Laba Rugi
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +22,Balance Sheet,Neraca
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +35,Company,Perusahaan
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +36,Select Company...,Pilih Perusahaan ...
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +41,Fiscal Year,Tahun Fiskal
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +42,Select Fiscal Year...,Pilih Tahun Anggaran ...
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +43,From Date,Dari Tanggal
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +44,To,untuk
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +45,To Date,Untuk Tanggal
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +46,Range,Jarak
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +47,Daily,Sehari-hari
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +47,Weekly,Mingguan
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +48,Quarterly,Triwulanan
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +49,Yearly,Tahunan
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +51,Reset Filters,Atur Ulang Filter
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +55,Plot,Plot
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +57,Account,Akun
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +59,Opening (Dr),Pembukaan (Dr)
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +61,Opening (Cr),Pembukaan (Cr)
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +9,Financial Analytics,Analytics keuangan
apps/erpnext/erpnext/accounts/page/pos/pos.js +12,Please setup your POS Preferences,
apps/erpnext/erpnext/accounts/page/pos/pos.js +14,Make new POS Setting,
apps/erpnext/erpnext/accounts/page/pos/pos.js +15,Start,Mulai
apps/erpnext/erpnext/accounts/page/pos/pos.js +23,Billing (Sales Invoice),
apps/erpnext/erpnext/accounts/page/pos/pos.js +4,Start POS,
apps/erpnext/erpnext/accounts/page/pos/pos.js +9,Select type of transaction,
apps/erpnext/erpnext/accounts/party.py +132,Please select company first.,Silakan pilih perusahaan pertama.
apps/erpnext/erpnext/accounts/party.py +176,Due Date cannot be before Posting Date,Tanggal jatuh tempo tidak bisa sebelum Tanggal Posting
apps/erpnext/erpnext/accounts/party.py +182,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),
apps/erpnext/erpnext/accounts/party.py +186,Due / Reference Date cannot be after {0},
apps/erpnext/erpnext/accounts/party.py +27,Not permitted,Tidak diijinkan
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +15,Supplier,Pemasok
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,Date,Tanggal
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Umur Berdasarkan
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +17,Ref,Ref
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18,Party,Pihak
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +19,Invoiced Amount,
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +20,Paid Amount,Dibayar Jumlah
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Total Invoiced Amount,Jumlah Total Tagihan
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Paid Amount,
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +26,Total Outstanding Amount,
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +34,Posting Date,Tanggal Posting
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +36,Voucher Type,Voucher Type
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +37,Voucher No,Voucher Tidak ada
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +38,Customer,Layanan Pelanggan
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +40,Territory,Wilayah
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +42,Supplier Type,Pemasok Type
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +44,Remarks,Keterangan
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68,Total Invoiced Amt,
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +69,Total Paid Amt,
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +70,Total Outstanding Amt,
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +8,Until,
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +28,Due Date,Tanggal Jatuh Tempo
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +31,Bill Date,Bill Tanggal
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +31,Bill No,Bill ada
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +34,Age,
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +38,-Above,
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +32,Provisional Profit / Loss (Credit),Laba Provisional / Rugi (Kredit)
apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.js +21,Bank Account,Bank Account/Rekening Bank
apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py +18,Against Account,Terhadap Akun
apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py +18,Clearance Date,Izin Tanggal
apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py +19,Credit,Piutang
apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py +19,Debit,Debet
apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py +25,Please select Bank Account,Silakan pilih Rekening Bank
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html +12,Reference,Referensi
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html +23,Against,Terhadap
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html +26,Ref Date,
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html +27,Reference Date,Referensi Tanggal
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html +4,Bank Reconciliation Statement,Pernyataan Rekonsiliasi Bank
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +39,System Balance,
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +41,Amounts not reflected in bank,
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Amounts not reflected in system,
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +44,Expected balance as per bank,
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +15,Period,periode
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +45,Please specify,Silakan tentukan
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Cost Center,Biaya Pusat
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +53,Actual,Aktual
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +53,Target,Sasaran
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +53,Variance,
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +61,Total Actual,
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +61,Total Target,
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +62,Total Variance,
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.
apps/erpnext/erpnext/accounts/report/financial_statements.py +149,Total ({0}),Jumlah ({0})
apps/erpnext/erpnext/accounts/report/financial_statements.py +16,Fiscal Year {0} not found.,
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +4,Statement of Account,Pernyataan Rekening
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +8,to,to
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +55,Group by Voucher,Group by Voucher
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +61,Group by Account,Group by Akun
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +24,Account {0} does not exists,
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +28,"Can not filter based on Account, if grouped by Account","Tidak dapat memfilter berdasarkan Account, jika dikelompokkan berdasarkan Account"
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +31,"Can not filter based on Voucher No, if grouped by Voucher","Tidak dapat memfilter berdasarkan No. Voucher, jika dikelompokkan berdasarkan Voucher"
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +34,From Date must be before To Date,Dari Tanggal harus sebelum To Date
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +70,Account {0} is not valid,Akun {0} tidak valid
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +27,Group By,
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +53,Sales Invoice,Faktur Penjualan
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +55,Posting Time,Posting Waktu
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +56,Item Code,Item Code
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +57,Item Name,Nama Item
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +58,Item Group,Item Grup
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +59,Brand,Merek
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +60,Description,Deskripsi
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +61,Warehouse,Gudang
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +62,Qty,Qty
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +63,Avg. Selling Rate,
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +64,Avg. Buying Rate,
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +65,Selling Amount,
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +66,Buying Amount,Jumlah Pembelian
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +67,Gross Profit,Laba Kotor
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Gross Profit %,
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Project,Proyek
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Sales person,
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Allocated Amount,Jumlah alokasi
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +73,Customer Group,Kelompok Pelanggan
apps/erpnext/erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py +45,Invoice,
apps/erpnext/erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py +48,Purchase Order,Purchase Order
apps/erpnext/erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py +49,Expense Account,Beban Akun
apps/erpnext/erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py +49,Purchase Receipt,Penerimaan Pembelian
apps/erpnext/erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py +50,Amount,Jumlah
apps/erpnext/erpnext/accounts/report/item_wise_purchase_register/item_wise_purchase_register.py +50,Rate,Menilai
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +46,Customer Name,Nama nasabah
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +47,Receivable Account,
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +49,Delivery Note,Pengiriman Note
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +49,Sales Order,Sales Order
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +50,Income Account,Akun Penghasilan
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js +20,Payment Type,Jenis Pembayaran
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +41,Against Invoice,
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +42,Against Invoice Posting Date,
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +43,Reference No,
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,90-Above,
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +68,No Customer or Supplier Accounts found,"Tidak ada pelanggan, atau pemasok Akun ditemukan"
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +30,Net Profit / Loss,Laba / Rugi
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +17,No record found,Tidak ada catatan ditemukan
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +66,Supplier Id,
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +67,Payable Account,
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +67,Supplier Name,Pemasok Nama
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +92,Total Tax,
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +93,Rounded Total,Rounded Jumlah
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py +65,Customer Id,
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +50,Period Closing Entry,
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +56,Show zero values,
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +186,Closing (Dr),Penutup (Dr)
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +192,Closing (Cr),Penutup (Cr)
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +34,From Date cannot be greater than To Date,Dari Tanggal tidak dapat lebih besar dari To Date
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +37,From Date should be within the Fiscal Year. Assuming From Date = {0},Dari tanggal harus dalam Tahun Anggaran. Dengan asumsi Dari Tanggal = {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,To Date should be within the Fiscal Year. Assuming To Date = {0},Untuk tanggal harus dalam Tahun Anggaran. Dengan asumsi To Date = {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +81,Total,Total
apps/erpnext/erpnext/accounts/utils.py +175,Payment Entry has been modified after you pulled it. Please pull it again.,
apps/erpnext/erpnext/accounts/utils.py +179,Allocated amount can not be negative,Jumlah yang dialokasikan tidak dijinkan negatif
apps/erpnext/erpnext/accounts/utils.py +181,Allocated amount can not greater than unadusted amount,Jumlah yang dialokasikan tidak boleh lebih besar dari sisa jumlah 
apps/erpnext/erpnext/accounts/utils.py +228,Journal Vouchers {0} are un-linked,Journal Voucher {0} yang un-linked
apps/erpnext/erpnext/accounts/utils.py +236,Please set default value {0} in Company {1},
apps/erpnext/erpnext/accounts/utils.py +295,Monthly,Bulanan
apps/erpnext/erpnext/accounts/utils.py +299,Annual,Tahunan
apps/erpnext/erpnext/accounts/utils.py +304,{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} anggaran untuk Akun {1} terhadap Biaya Pusat {2} akan melebihi oleh {3}
apps/erpnext/erpnext/accounts/utils.py +35,{0} {1} not in any Fiscal Year,{0} {1} tidak dalam Tahun Anggaran
apps/erpnext/erpnext/accounts/utils.py +43,{0} '{1}' not in Fiscal Year {2},{0} '{1}' tidak dalam Tahun Anggaran {2}
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +113,Item {0} has been entered multiple times with same description or date or warehouse,Item {0} sudah dimasukkan beberapa kali dengan deskripsi atau tanggal atau gudang yang sama
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +120,Item {0} has been entered multiple times with same description or date,Item {0} sudah dimasukkan beberapa kali dengan deskripsi atau tanggal yang sama
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +128,{0} {1} status is 'Stopped',{0} {1} status 'Berhenti'
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +136,{0} {1} has already been submitted,{0} {1} telah diserahkan
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +34,UOM Conversion factor is required in row {0},Faktor UOM Konversi diperlukan berturut-turut {0}
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +71,Please enter quantity for Item {0},Mohon masukkan untuk Item {0}
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +92,Warehouse is mandatory for stock Item {0} in row {1},Gudang adalah wajib bagi saham Barang {0} berturut-turut {1}
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +97,{0} must be a Purchased or Sub-Contracted Item in row {1},{0} harus Dibeli Sub-Kontrak atau Barang berturut-turut {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +158,Do you really want to STOP ,Do you really want to STOP 
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +169,Do you really want to UNSTOP ,Do you really want to UNSTOP 
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +20,% Received,% Diterima
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +22,% Billed,Ditagih%
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +26,Make Purchase Receipt,Membuat Pembelian Penerimaan
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +29,Make Invoice,Membuat Invoice
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +32,Stop,Berhenti
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +42,Unstop Purchase Order,Unstop Purchase Order
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +61,From Material Request,Dari Material Permintaan
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +77,From Supplier Quotation,Dari Pemasok Quotation
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +91,For Supplier,Untuk Pemasok
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +110,Material Request {0} is cancelled or stopped,Permintaan Material {0} dibatalkan atau dihentikan
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +145,{0} {1} has been modified. Please refresh.,{0} {1} telah dimodifikasi. Silahkan refresh.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +155,Status of {0} {1} is now {2},Status {0} {1} sekarang {2}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +186,Purchase Invoice {0} is already submitted,Purchase Invoice {0} sudah disampaikan
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +80,Item #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.html +12,Pending,Menunggu
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.html +27,Received,Diterima
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.html +31,Billed,Ditagih
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +44,Total Billing This Year: ,Total Billing This Year: 
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +46,Unpaid,Tunggakan
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +46,Series is mandatory,Series adalah wajib
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +85,No permission,Tidak ada izin
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +19,Make Purchase Order,Membuat Purchase Order
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +132,All Supplier Types,Semua Jenis pemasok
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +141,Not Set,Tidak Diatur
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +34,Supplier Type / Supplier,Pemasok Type / Pemasok
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +7,Purchase Analytics,Pembelian Analytics
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Tree Type,Jenis Pohon
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +94,Based On,Berdasarkan
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +96,Value or Qty,Nilai atau Qty
apps/erpnext/erpnext/config/accounts.py +101,Default settings for accounting transactions.,Pengaturan default untuk transaksi akuntansi.
apps/erpnext/erpnext/config/accounts.py +106,Tax template for selling transactions.,Template Pajak menjual transaksi.
apps/erpnext/erpnext/config/accounts.py +111,Tax template for buying transactions.,Template pajak untuk membeli transaksi.
apps/erpnext/erpnext/config/accounts.py +116,Point-of-Sale Setting,Point-of-Sale Pengaturan
apps/erpnext/erpnext/config/accounts.py +117,Rules to calculate shipping amount for a sale,Aturan untuk menghitung jumlah pengiriman untuk penjualan
apps/erpnext/erpnext/config/accounts.py +12,Accounting journal entries.,Pencatatan Jurnal akuntansi.
apps/erpnext/erpnext/config/accounts.py +122,Rules for adding shipping costs.,Aturan untuk menambahkan biaya pengiriman.
apps/erpnext/erpnext/config/accounts.py +127,Rules for applying pricing and discount.,Aturan untuk menerapkan harga dan diskon.
apps/erpnext/erpnext/config/accounts.py +132,Enable / disable currencies.,Mengaktifkan / menonaktifkan mata uang.
apps/erpnext/erpnext/config/accounts.py +137,Currency exchange rate master.,Menguasai nilai tukar mata uang.
apps/erpnext/erpnext/config/accounts.py +142,Seasonality for setting budgets.,Musiman untuk menetapkan anggaran.
apps/erpnext/erpnext/config/accounts.py +147,Terms and Conditions Template,Syarat dan Ketentuan Template
apps/erpnext/erpnext/config/accounts.py +148,Template of terms or contract.,Template istilah atau kontrak.
apps/erpnext/erpnext/config/accounts.py +153,"e.g. Bank, Cash, Credit Card","misalnya Bank, Kas, Kartu Kredit"
apps/erpnext/erpnext/config/accounts.py +158,C-Form records,C-Form catatan
apps/erpnext/erpnext/config/accounts.py +164,Main Reports,Laporan Utama
apps/erpnext/erpnext/config/accounts.py +17,Bills raised to Customers.,Bills diajukan ke Pelanggan.
apps/erpnext/erpnext/config/accounts.py +22,Bills raised by Suppliers.,Bills diajukan oleh Pemasok.
apps/erpnext/erpnext/config/accounts.py +230,Standard Reports,Laporan standar
apps/erpnext/erpnext/config/accounts.py +27,Customer database.,Database pelanggan.
apps/erpnext/erpnext/config/accounts.py +32,Supplier database.,Database Supplier.
apps/erpnext/erpnext/config/accounts.py +40,Tree of finanial accounts.,Pohon rekening finanial.
apps/erpnext/erpnext/config/accounts.py +46,Tools,Alat-alat
apps/erpnext/erpnext/config/accounts.py +52,Update bank payment dates with journals.,Perbarui tanggal pembayaran bank dengan jurnal.
apps/erpnext/erpnext/config/accounts.py +57,Match non-linked Invoices and Payments.,Cocokkan Faktur non-linked dan Pembayaran.
apps/erpnext/erpnext/config/accounts.py +6,Documents,Docuements
apps/erpnext/erpnext/config/accounts.py +62,Close Balance Sheet and book Profit or Loss.,Tutup Neraca dan Perhitungan Laba Rugi atau buku.
apps/erpnext/erpnext/config/accounts.py +67,Create Payment Entries against Orders or Invoices.,
apps/erpnext/erpnext/config/accounts.py +72,Setup,Pengaturan
apps/erpnext/erpnext/config/accounts.py +78,Financial / accounting year.,Keuangan / akuntansi tahun.
apps/erpnext/erpnext/config/accounts.py +95,Tree of finanial Cost Centers.,Pohon Pusat Biaya finanial.
apps/erpnext/erpnext/config/buying.py +17,Request for purchase.,Permintaan pembelian.
apps/erpnext/erpnext/config/buying.py +22,Quotations received from Suppliers.,Kutipan yang diterima dari pemasok.
apps/erpnext/erpnext/config/buying.py +27,Purchase Orders given to Suppliers.,Pembelian Pesanan yang diberikan kepada Pemasok.
apps/erpnext/erpnext/config/buying.py +32,All Contacts.,Semua Kontak.
apps/erpnext/erpnext/config/buying.py +37,All Addresses.,Semua Alamat
apps/erpnext/erpnext/config/buying.py +42,All Products or Services.,Semua Produk atau Jasa.
apps/erpnext/erpnext/config/buying.py +53,Default settings for buying transactions.,Pengaturan default untuk membeli transaksi.
apps/erpnext/erpnext/config/buying.py +58,Supplier Type master.,Pemasok Type induk.
apps/erpnext/erpnext/config/buying.py +64,Item Group Tree,Item Grup Pohon
apps/erpnext/erpnext/config/buying.py +66,Tree of Item Groups.,Pohon Item Grup.
apps/erpnext/erpnext/config/buying.py +83,Price List master.,Daftar harga Master.
apps/erpnext/erpnext/config/buying.py +88,Multiple Item prices.,Multiple Item harga.
apps/erpnext/erpnext/config/desktop.py +18,Human Resources,Sumber Daya Manusia
apps/erpnext/erpnext/config/desktop.py +55,Shopping Cart,Daftar Belanja
apps/erpnext/erpnext/config/hr.py +104,Organization unit (department) master.,Unit Organisasi (kawasan) menguasai.
apps/erpnext/erpnext/config/hr.py +109,"Employee designation (e.g. CEO, Director etc.).","Penunjukan Karyawan (misalnya CEO, Direktur dll)."
apps/erpnext/erpnext/config/hr.py +114,Salary template master.,Master Gaji Template.
apps/erpnext/erpnext/config/hr.py +119,Salary components.,Komponen gaji.
apps/erpnext/erpnext/config/hr.py +12,Employee records.,Catatan karyawan.
apps/erpnext/erpnext/config/hr.py +124,Tax and other salary deductions.,Pajak dan pemotongan gaji lainnya.
apps/erpnext/erpnext/config/hr.py +129,Allocate leaves for a period.,Alokasi cuti untuk periode tertentu
apps/erpnext/erpnext/config/hr.py +134,"Type of leaves like casual, sick etc.","Jenis daun seperti kasual, dll sakit"
apps/erpnext/erpnext/config/hr.py +139,Holiday master.,Master Holiday.
apps/erpnext/erpnext/config/hr.py +144,Block leave applications by department.,Memblokir aplikasi cuti berdasarkan departemen.
apps/erpnext/erpnext/config/hr.py +149,Template for performance appraisals.,Template untuk penilaian kinerja.
apps/erpnext/erpnext/config/hr.py +154,Types of Expense Claim.,Jenis Beban Klaim.
apps/erpnext/erpnext/config/hr.py +159,Setup incoming server for jobs email id. (e.g. jobs@example.com),Pengaturan server masuk untuk pekerjaan email id. (Misalnya jobs@example.com)
apps/erpnext/erpnext/config/hr.py +17,Applications for leave.,Aplikasi untuk cuti.
apps/erpnext/erpnext/config/hr.py +22,Claims for company expense.,Klaim untuk biaya perusahaan.
apps/erpnext/erpnext/config/hr.py +27,Attendance record.,Catatan kehadiran.
apps/erpnext/erpnext/config/hr.py +32,Monthly salary statement.,Pernyataan gaji bulanan.
apps/erpnext/erpnext/config/hr.py +37,Performance appraisal.,Penilaian kinerja.
apps/erpnext/erpnext/config/hr.py +42,Applicant for a Job.,Pemohon untuk pekerjaan.
apps/erpnext/erpnext/config/hr.py +47,Opening for a Job.,Membuka untuk Job.
apps/erpnext/erpnext/config/hr.py +58,Process Payroll,Proses Payroll
apps/erpnext/erpnext/config/hr.py +59,Generate Salary Slips,Menghasilkan Gaji Slips
apps/erpnext/erpnext/config/hr.py +65,Upload attendance from a .csv file,Upload kehadiran dari file csv.
apps/erpnext/erpnext/config/hr.py +71,Leave Allocation Tool,Tinggalkan Alokasi Alat
apps/erpnext/erpnext/config/hr.py +72,Allocate leaves for the year.,Alokasi cuti untuk tahunan.
apps/erpnext/erpnext/config/hr.py +84,Settings for HR Module,Pengaturan untuk modul HR
apps/erpnext/erpnext/config/hr.py +89,Employee master.,Master Karyawan.
apps/erpnext/erpnext/config/hr.py +94,"Types of employment (permanent, contract, intern etc.).","Jenis pekerjaan (permanen, kontrak, magang dll)."
apps/erpnext/erpnext/config/hr.py +99,Organization branch master.,Cabang master organisasi.
apps/erpnext/erpnext/config/manufacturing.py +12,Bill of Materials (BOM),Bill of Material (BOM)
apps/erpnext/erpnext/config/manufacturing.py +13,Bill of Material,Bill of Material
apps/erpnext/erpnext/config/manufacturing.py +18,Orders released for production.,Pesanan dirilis untuk produksi.
apps/erpnext/erpnext/config/manufacturing.py +28,Where manufacturing operations are carried out.,Dimana operasi manufaktur dilakukan.
apps/erpnext/erpnext/config/manufacturing.py +40,Generate Material Requests (MRP) and Production Orders.,Menghasilkan Permintaan Material (MRP) dan Pesanan Produksi.
apps/erpnext/erpnext/config/manufacturing.py +45,Replace Item / BOM in all BOMs,Ganti Barang / BOM di semua BOMs
apps/erpnext/erpnext/config/projects.py +12,Project activity / task.,Kegiatan proyek / tugas.
apps/erpnext/erpnext/config/projects.py +17,Project master.,Menguasai proyek.
apps/erpnext/erpnext/config/projects.py +22,Time Log for tasks.,Waktu Log untuk tugas-tugas.
apps/erpnext/erpnext/config/projects.py +27,Batch Time Logs for billing.,Batch Sisa log untuk penagihan.
apps/erpnext/erpnext/config/projects.py +32,Types of activities for Time Sheets,Jenis kegiatan untuk Waktu Sheets
apps/erpnext/erpnext/config/projects.py +45,Gantt chart of all tasks.,Gantt chart dari semua tugas.
apps/erpnext/erpnext/config/selling.py +102,Manage Sales Partners.,Mengelola Penjualan Partners.
apps/erpnext/erpnext/config/selling.py +106,Sales Person,Penjualan Orang
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Person Tree.,Mengelola Penjualan Orang Pohon.
apps/erpnext/erpnext/config/selling.py +12,Database of potential customers.,Database pelanggan potensial.
apps/erpnext/erpnext/config/selling.py +157,Bundle items at time of sale.,Bundel item pada saat penjualan.
apps/erpnext/erpnext/config/selling.py +162,Setup incoming server for sales email id. (e.g. sales@example.com),Pengaturan server masuk untuk email penjualan id. (Misalnya sales@example.com)
apps/erpnext/erpnext/config/selling.py +167,Track Leads by Industry Type.,Melacak Memimpin menurut Industri Type.
apps/erpnext/erpnext/config/selling.py +172,Setup SMS gateway settings,Pengaturan gerbang Pengaturan SMS
apps/erpnext/erpnext/config/selling.py +183,Sales Analytics,Penjualan Analytics
apps/erpnext/erpnext/config/selling.py +189,Sales Funnel,Penjualan Saluran
apps/erpnext/erpnext/config/selling.py +22,Potential opportunities for selling.,Potensi peluang untuk menjual.
apps/erpnext/erpnext/config/selling.py +27,Quotes to Leads or Customers.,Harga untuk Memimpin atau Pelanggan.
apps/erpnext/erpnext/config/selling.py +32,Confirmed orders from Customers.,Dikonfirmasi pesanan dari pelanggan.
apps/erpnext/erpnext/config/selling.py +58,Send mass SMS to your contacts,Kirim SMS massal ke kontak Anda
apps/erpnext/erpnext/config/selling.py +63,"Newsletters to contacts, leads.","Newsletter ke kontak, memimpin."
apps/erpnext/erpnext/config/selling.py +74,Default settings for selling transactions.,Pengaturan default untuk menjual transaksi.
apps/erpnext/erpnext/config/selling.py +79,Sales campaigns.,Kampanye penjualan.
apps/erpnext/erpnext/config/selling.py +87,Manage Customer Group Tree.,Manage Group Pelanggan Pohon.
apps/erpnext/erpnext/config/selling.py +96,Manage Territory Tree.,Kelola Wilayah Pohon.
apps/erpnext/erpnext/config/setup.py +100,Customer master.,Master pelanggan.
apps/erpnext/erpnext/config/setup.py +105,Supplier master.,Pemasok utama.
apps/erpnext/erpnext/config/setup.py +110,Contact master.,Kontak utama.
apps/erpnext/erpnext/config/setup.py +115,Address master.,Alamat utama.
apps/erpnext/erpnext/config/setup.py +122,Accounts,Akun / Rekening
apps/erpnext/erpnext/config/setup.py +123,Stock,Stock
apps/erpnext/erpnext/config/setup.py +124,Selling,Penjualan
apps/erpnext/erpnext/config/setup.py +125,Buying,Pembelian
apps/erpnext/erpnext/config/setup.py +127,Support,Mendukung
apps/erpnext/erpnext/config/setup.py +13,Global Settings,Pengaturan global
apps/erpnext/erpnext/config/setup.py +14,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Set Nilai Default seperti Perusahaan, Mata Uang, Tahun Anggaran Current, dll"
apps/erpnext/erpnext/config/setup.py +20,Printing and Branding,Percetakan dan Branding
apps/erpnext/erpnext/config/setup.py +26,Letter Heads for print templates.,Surat Kepala untuk mencetak template.
apps/erpnext/erpnext/config/setup.py +31,Titles for print templates e.g. Proforma Invoice.,Judul untuk mencetak template misalnya Proforma Invoice.
apps/erpnext/erpnext/config/setup.py +36,Country wise default Address Templates,Negara bijaksana Alamat bawaan Template
apps/erpnext/erpnext/config/setup.py +41,Standard contract terms for Sales or Purchase.,Ketentuan kontrak standar untuk Penjualan atau Pembelian.
apps/erpnext/erpnext/config/setup.py +46,Customize,Sesuaikan
apps/erpnext/erpnext/config/setup.py +52,"Show / Hide features like Serial Nos, POS etc.","Tampilkan / Sembunyikan fitur seperti Serial Nos, POS dll"
apps/erpnext/erpnext/config/setup.py +57,Create rules to restrict transactions based on values.,Buat aturan untuk membatasi transaksi berdasarkan nilai-nilai.
apps/erpnext/erpnext/config/setup.py +62,Email Notifications,Notifikasi Email
apps/erpnext/erpnext/config/setup.py +63,Automatically compose message on submission of transactions.,Secara otomatis menulis pesan pada pengajuan transaksi.
apps/erpnext/erpnext/config/setup.py +68,Email,Email
apps/erpnext/erpnext/config/setup.py +7,Settings,Pengaturan
apps/erpnext/erpnext/config/setup.py +74,"Create and manage daily, weekly and monthly email digests.","Membuat dan mengelola harian, mingguan dan bulanan mencerna email."
apps/erpnext/erpnext/config/setup.py +84,Masters,Masters
apps/erpnext/erpnext/config/setup.py +90,Company (not Customer or Supplier) master.,Perusahaan (tidak Pelanggan atau Pemasok) Master.
apps/erpnext/erpnext/config/setup.py +95,Item master.,Master barang.
apps/erpnext/erpnext/config/stock.py +108,Unit of Measure,Satuan Ukur
apps/erpnext/erpnext/config/stock.py +109,"e.g. Kg, Unit, Nos, m","misalnya Kg, Unit, Nos, m"
apps/erpnext/erpnext/config/stock.py +114,Warehouses.,Gudang.
apps/erpnext/erpnext/config/stock.py +119,Brand master.,Master merek.
apps/erpnext/erpnext/config/stock.py +12,Requests for items.,Permintaan untuk item.
apps/erpnext/erpnext/config/stock.py +135,"Attributes for Item Variants. e.g Size, Color etc.",
apps/erpnext/erpnext/config/stock.py +17,Record item movement.,Gerakan barang Rekam.
apps/erpnext/erpnext/config/stock.py +176,Stock Analytics,Stock Analytics
apps/erpnext/erpnext/config/stock.py +22,Shipments to customers.,Pengiriman ke pelanggan.
apps/erpnext/erpnext/config/stock.py +27,Goods received from Suppliers.,Barang yang diterima dari pemasok.
apps/erpnext/erpnext/config/stock.py +32,Installation record for a Serial No.,Catatan instalasi untuk No Serial
apps/erpnext/erpnext/config/stock.py +42,Where items are stored.,Dimana item disimpan.
apps/erpnext/erpnext/config/stock.py +47,Single unit of an Item.,Unit tunggal Item.
apps/erpnext/erpnext/config/stock.py +52,Batch (lot) of an Item.,Batch (banyak) dari Item.
apps/erpnext/erpnext/config/stock.py +63,Upload stock balance via csv.,Upload keseimbangan saham melalui csv.
apps/erpnext/erpnext/config/stock.py +68,Split Delivery Note into packages.,Membagi Pengiriman Catatan ke dalam paket.
apps/erpnext/erpnext/config/stock.py +73,Incoming quality inspection.,Pemeriksaan mutu yang masuk.
apps/erpnext/erpnext/config/stock.py +78,Update additional costs to calculate landed cost of items,
apps/erpnext/erpnext/config/stock.py +83,Change UOM for an Item.,Mengubah UOM untuk Item.
apps/erpnext/erpnext/config/stock.py +94,Default settings for stock transactions.,Pengaturan default untuk transaksi saham.
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Permintaan dukungan dari pelanggan.
apps/erpnext/erpnext/config/support.py +17,Customer Issue against Serial No.,Issue pelanggan terhadap Serial Number
apps/erpnext/erpnext/config/support.py +22,Plan for maintenance visits.,Rencana kunjungan pemeliharaan.
apps/erpnext/erpnext/config/support.py +27,Visit report for maintenance call.,Kunjungi laporan untuk panggilan pemeliharaan.
apps/erpnext/erpnext/config/support.py +37,Communication log.,Log komunikasi.
apps/erpnext/erpnext/config/support.py +53,Setup incoming server for support email id. (e.g. support@example.com),Pengaturan server masuk untuk email dukungan id. (Misalnya support@example.com)
apps/erpnext/erpnext/config/support.py +64,Support Analytics,Dukungan Analytics
apps/erpnext/erpnext/controllers/accounts_controller.py +207,Please specify a valid Row ID for {0} in row {1},Silakan tentukan ID Row berlaku untuk {0} berturut-turut {1}
apps/erpnext/erpnext/controllers/accounts_controller.py +211,"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 Barang, pajak dalam baris {1} juga harus disertakan"
apps/erpnext/erpnext/controllers/accounts_controller.py +217,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/controllers/accounts_controller.py +351,{0} '{1}' is disabled,
apps/erpnext/erpnext/controllers/accounts_controller.py +446,"Journal Voucher {0} is linked against Order {1}, hence it must be fetched as advance in Invoice as well.",
apps/erpnext/erpnext/controllers/accounts_controller.py +460,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
apps/erpnext/erpnext/controllers/accounts_controller.py +476,"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings","Tidak bisa overbill untuk Item {0} di baris {0} lebih dari {1}. Untuk memungkinkan mark up, atur di Bursa Settings"
apps/erpnext/erpnext/controllers/accounts_controller.py +514,"Total advance ({0}) against Order {1} cannot be greater \
				than the Grand Total ({2})",
apps/erpnext/erpnext/controllers/accounts_controller.py +552,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} adalah wajib. Mungkin catatan mata uang tidak diciptakan untuk {1} ke {} 2.
apps/erpnext/erpnext/controllers/buying_controller.py +213,Please enter 'Is Subcontracted' as Yes or No,Masukkan 'Apakah subkontrak' sebagai Ya atau Tidak
apps/erpnext/erpnext/controllers/buying_controller.py +217,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Pemasok Gudang wajib untuk Pembelian Penerimaan sub-kontrak
apps/erpnext/erpnext/controllers/buying_controller.py +221,Please select BOM in BOM field for Item {0},
apps/erpnext/erpnext/controllers/buying_controller.py +24,From {0} | {1} {2},
apps/erpnext/erpnext/controllers/buying_controller.py +330,Specified BOM {0} does not exist for Item {1},
apps/erpnext/erpnext/controllers/buying_controller.py +363,Item table can not be blank,Tabel barang tidak boleh kosong
apps/erpnext/erpnext/controllers/buying_controller.py +369,Row {0}: Conversion Factor is mandatory,Row {0}: Faktor Konversi adalah wajib
apps/erpnext/erpnext/controllers/buying_controller.py +73,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,Pajak Kategori tidak bisa 'Penilaian' atau 'Penilaian dan Total' karena semua item item non-saham
apps/erpnext/erpnext/controllers/recurring_document.py +125,New {0}: #{1},
apps/erpnext/erpnext/controllers/recurring_document.py +126,Please find attached {0} #{1},
apps/erpnext/erpnext/controllers/recurring_document.py +163,Please select {0},Silahkan pilih {0}
apps/erpnext/erpnext/controllers/recurring_document.py +167,Period From and Period To dates mandatory for recurring %s,
apps/erpnext/erpnext/controllers/recurring_document.py +190,"{0} is an invalid email address in 'Notification \
					Email Address'",
apps/erpnext/erpnext/controllers/recurring_document.py +194,'Notification Email Addresses' not specified for recurring %s,
apps/erpnext/erpnext/controllers/recurring_document.py +201,Please enter 'Repeat on Day of Month' field value,Masukkan 'Ulangi pada Hari Bulan' nilai bidang
apps/erpnext/erpnext/controllers/recurring_document.py +208,Next Recurring {0} will be created on {1},
apps/erpnext/erpnext/controllers/selling_controller.py +22,To {0} | {1} {2},
apps/erpnext/erpnext/controllers/selling_controller.py +278,Commission rate cannot be greater than 100,Tingkat komisi tidak dapat lebih besar dari 100
apps/erpnext/erpnext/controllers/selling_controller.py +299,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 +306,Order Type must be one of {0},Pesanan Type harus menjadi salah satu {0}
apps/erpnext/erpnext/controllers/selling_controller.py +313,Maxiumm discount for Item {0} is {1}%,Diskon Maxiumm untuk Item {0} adalah {1}%
apps/erpnext/erpnext/controllers/selling_controller.py +322,Row {0}: Qty is mandatory,Row {0}: Qty adalah wajib
apps/erpnext/erpnext/controllers/selling_controller.py +327,Reserved Warehouse required for stock Item {0} in row {1},Reserved Gudang diperlukan untuk stok Barang {0} berturut-turut {1}
apps/erpnext/erpnext/controllers/selling_controller.py +397,Sales Order {0} is stopped,Sales Order {0} dihentikan
apps/erpnext/erpnext/controllers/selling_controller.py +406,Item {0} must be Sales or Service Item in {1},Item {0} harus Penjualan atau Jasa Barang di {1}
apps/erpnext/erpnext/controllers/status_updater.py +100,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Catatan: Sistem tidak akan memeriksa over-pengiriman dan over-booking untuk Item {0} kuantitas atau jumlah 0
apps/erpnext/erpnext/controllers/status_updater.py +104,Allowance for over-{0} crossed for Item {1},Penyisihan over-{0} menyeberang untuk Item {1}
apps/erpnext/erpnext/controllers/status_updater.py +106,{0} must be reduced by {1} or you should increase overflow tolerance,{0} harus dikurangi oleh {1} atau Anda harus meningkatkan toleransi melimpah
apps/erpnext/erpnext/controllers/status_updater.py +127,Allowance for over-{0} crossed for Item {1}.,Penyisihan over-{0} menyeberang untuk Item {1}.
apps/erpnext/erpnext/controllers/stock_controller.py +165,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Beban atau Selisih akun adalah wajib untuk Item {0} karena dampak keseluruhan nilai saham
apps/erpnext/erpnext/controllers/stock_controller.py +171,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Beban akun / Difference ({0}) harus akun 'Laba atau Rugi'
apps/erpnext/erpnext/controllers/stock_controller.py +174,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Biaya Pusat adalah wajib untuk Item {2}
apps/erpnext/erpnext/controllers/stock_controller.py +70,No accounting entries for the following warehouses,Tidak ada entri akuntansi untuk gudang berikut
apps/erpnext/erpnext/controllers/trends.py +134,Amt,
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),
apps/erpnext/erpnext/controllers/trends.py +254,Project-wise data is not available for Quotation,Data proyek-bijaksana tidak tersedia untuk Quotation
apps/erpnext/erpnext/controllers/trends.py +33,{0} is mandatory,{0} adalah wajib
apps/erpnext/erpnext/controllers/trends.py +36,'Based On' and 'Group By' can not be same,'Berdasarkan' dan 'Group By' tidak bisa sama
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
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +30,End Date can not be less than Start Date,Tanggal akhir tidak boleh kurang dari Tanggal Mulai
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +39,Appraisal {0} created for Employee {1} in the given date range,Penilaian {0} telah dibuat untuk karyawan {1} dalam rentang tanggal tertentu
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +50,Total weightage assigned should be 100%. It is {0},Jumlah weightage ditugaskan harus 100%. Ini adalah {0}
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +54,Total cannot be zero,Jumlah tidak boleh nol
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +17,Total points for all goals should be 100. It is {0},Jumlah poin untuk semua tujuan harus 100. Ini adalah {0}
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Kehadiran bagi karyawan {0} sudah ditandai
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} was on leave on {1}. Cannot mark attendance.,Karyawan {0} sedang cuti pada {1}. Tidak bisa menandai kehadiran.
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +38,Attendance can not be marked for future dates,Kehadiran tidak dapat ditandai untuk tanggal masa depan
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +44,Employee {0} is not active or does not exist,Karyawan {0} tidak aktif atau tidak ada
apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.html +8,Status,Status
apps/erpnext/erpnext/hr/doctype/employee/employee.js +27,Make Salary Structure,Membuat Struktur Gaji
apps/erpnext/erpnext/hr/doctype/employee/employee.py +103,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 +106,Date Of Retirement must be greater than Date of Joining,Tanggal Of Pensiun harus lebih besar dari Tanggal Bergabung
apps/erpnext/erpnext/hr/doctype/employee/employee.py +109,Relieving Date must be greater than Date of Joining,Menghilangkan Tanggal harus lebih besar dari Tanggal Bergabung
apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,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 +116,Please enter valid Company Email,Masukkan Perusahaan valid Email
apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Please enter valid Personal Email,Silahkan lakukan validasi Email Pribadi
apps/erpnext/erpnext/hr/doctype/employee/employee.py +122,Please enter relieving date.,Silahkan masukkan menghilangkan date.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +130,User {0} is disabled,Pengguna {0} dinonaktifkan
apps/erpnext/erpnext/hr/doctype/employee/employee.py +136,User {0} is already assigned to Employee {1},Pengguna {0} sudah ditugaskan untuk Karyawan {1}
apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,{0} is not a valid Leave Approver. Removing row #{1}.,{0} tidak valid Tinggalkan Approver. Menghapus row # {1}.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +148,Employee cannot report to himself.,
apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Birthday,Ulang tahun
apps/erpnext/erpnext/hr/doctype/employee/employee.py +168,Happy Birthday!,Happy Birthday!
apps/erpnext/erpnext/hr/doctype/employee/employee.py +212,Please set User ID field in an Employee record to set Employee Role,
apps/erpnext/erpnext/hr/doctype/employee/employee.py +25,Please setup Employee Naming System in Human Resource > HR Settings,Silahkan pengaturan Penamaan Sistem Karyawan di Sumber Daya Manusia> Pengaturan SDM
apps/erpnext/erpnext/hr/doctype/employee/employee_list.html +8,Active,Aktif
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +101,Fill the form and save it,Isi formulir dan menyimpannya
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,You are the Expense Approver for this record. Please Update the 'Status' and Save,Anda adalah Approver Beban untuk record ini. Silakan Update 'Status' dan Simpan
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +107,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 +111,Expense Claim has been approved.,Beban Klaim telah disetujui.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +113,Expense Claim has been rejected.,Beban Klaim telah ditolak.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +93,Make Bank Voucher,Membuat Bank Voucher
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +15,{0}: From {0} for {1},
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +26,Approval Status must be 'Approved' or 'Rejected',Status Persetujuan harus 'Disetujui' atau 'Ditolak'
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +34,Please add expense voucher details,Harap tambahkan beban rincian voucher
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +38,{0} ({1}) must have role 'Expense Approver',
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +33,Please select Fiscal Year,Silahkan pilih Tahun Anggaran
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +35,Please select weekly off day,Silakan pilih dari hari mingguan
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py +35,Updated Birthday Reminders,Diperbarui Ulang Tahun Pengingat
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +32,Leaves must be allocated in multiples of 0.5,"Daun harus dialokasikan dalam kelipatan 0,5"
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +40,Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Daun untuk tipe {0} sudah dialokasikan untuk Karyawan {1} Tahun Anggaran {0}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +68,Cannot carry forward {0},Tidak bisa meneruskan {0}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +97,Cannot cancel because Employee {0} is already approved for {1},Tidak dapat membatalkan karena Employee {0} sudah disetujui untuk {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +33,You are the Leave Approver for this record. Please Update the 'Status' and Save,Anda adalah Leave Approver untuk record ini. Silakan Update 'Status' dan Simpan
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +36,This Leave Application is pending approval. Only the Leave Apporver can update status.,Aplikasi Cuti ini menunggu persetujuan. Hanya Tinggalkan Apporver dapat memperbarui status.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +44,Leave application has been approved.,Pengajuan cuti telah disetujui.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +46,Please submit to update Leave Balance.,Harap kirimkan untuk memperbarui Leave Balance.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +49,Leave application has been rejected.,Pengajuan cuti telah ditolak.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +83,To Date should be same as From Date for Half Day leave,Untuk tanggal harus sama dengan Dari Tanggal untuk cuti Half Day
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +109,Note: There is not enough leave balance for Leave Type {0},Catatan: Tidak ada saldo cuti cukup bagi Leave Type {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +111,There is not enough leave balance for Leave Type {0},Tidak ada saldo cuti cukup bagi Leave Type {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +135,Employee {0} has already applied for {1} between {2} and {3},Karyawan {0} telah diterapkan untuk {1} antara {2} dan {3}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +142,Leave of type {0} cannot be longer than {1},Tinggalkan jenis {0} tidak boleh lebih dari {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Leave approver must be one of {0},Tinggalkan approver harus menjadi salah satu {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +153,{0} ({1}) must have role 'Leave Approver',
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +157,Only the selected Leave Approver can submit this Leave Application,Hanya dipilih Cuti Approver dapat mengirimkan Aplikasi Cuti ini
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +171,Leave Application,Tinggalkan Aplikasi
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +190,Employee,Karyawan
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +190,New Leave Application,Tinggalkan Aplikasi Baru
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +21,{0}: From {0} of type {1},
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +314, (Half Day), (Half Day)
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +331,Leave Blocked,Tinggalkan Diblokir
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +347,Holiday,Liburan
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' can be submitted,Hanya Tinggalkan Aplikasi status 'Disetujui' dapat diajukan
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +68,Warning: Leave application contains following block dates,Peringatan: Tinggalkan aplikasi berisi tanggal blok berikut
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +80,Cannot approve leave as you are not authorized to approve leaves on Block Dates,Tidak dapat menyetujui cuti karena Anda tidak berwenang untuk menyetujui daun di Blok Dates
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,To date cannot be before from date,Sampai saat ini tidak dapat sebelumnya dari tanggal
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +99,The day(s) on which you are applying for leave are holiday. You need not apply for leave.,Hari (s) yang Anda lamar untuk cuti adalah liburan. Anda tidak perlu mengajukan cuti.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_list.html +11,{0} days from {1},
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_list.html +22,Leave Type,Tinggalkan Type
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Block Date,Blokir Tanggal
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +23,Date is repeated,Tanggal diulang
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +39,No employee found,Tidak ada karyawan yang ditemukan
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +58,Leaves Allocated Successfully for {0},Daun Dialokasikan Berhasil untuk {0}
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +22,Do you really want to Submit all Salary Slip for month {0} and year {1},Apakah Anda benar-benar ingin Menyerahkan semua Slip Gaji untuk bulan {0} dan tahun {1}
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +36,"Company, Month and Fiscal Year is mandatory","Perusahaan, Bulan dan Tahun Anggaran adalah wajib"
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +45,Payment of salary for the month {0} and year {1},Pembayaran gaji untuk bulan {0} dan tahun {1}
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +8,Activity Log:,Log Aktivitas:
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.py +190,You can set Default Bank Account in Company master,Anda dapat mengatur default Bank Account menguasai Perusahaan
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.py +55,Please set {0},Silakan set {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +131,Salary Slip of employee {0} already created for this month,Slip Gaji karyawan {0} sudah diciptakan untuk bulan ini
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +191,Please see attachment,Silakan lihat lampiran
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +197,"Company Email ID not found, hence mail not sent","Perusahaan Email ID tidak ditemukan, maka surat tidak terkirim"
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +31,Please create Salary Structure for employee {0},Silakan membuat Struktur Gaji untuk karyawan {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +59,There are more holidays than working days this month.,Ada lebih dari hari kerja libur bulan ini.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +79,Employee relieved on {0} must be set as 'Left',Karyawan lega pada {0} harus ditetapkan sebagai 'Kiri'
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip_list.html +15,Month,Bulan
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +15,Make Salary Slip,Membuat Slip Gaji
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +59,Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Net pay cannot be negative,Gaji bersih yang belum dapat negatif
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +68,Employee can not be changed,
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +20,Attendance From Date and Attendance To Date is mandatory,Kehadiran Dari Tanggal dan Kehadiran Sampai Tanggal adalah wajib
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +59,Import Failed!,Impor Gagal!
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +62,Import Successful!,Impor Sukses!
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +105,Please select a csv file,Silakan pilih file csv
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +90,Please setup numbering series for Attendance via Setup > Numbering Series,Silahkan pengaturan seri penomoran untuk Kehadiran melalui Pengaturan> Penomoran Series
apps/erpnext/erpnext/hr/report/employee_birthday/employee_birthday.py +19,Date of Birth,Tanggal Lahir
apps/erpnext/erpnext/hr/report/employee_birthday/employee_birthday.py +19,Name,Nama
apps/erpnext/erpnext/hr/report/employee_birthday/employee_birthday.py +20,Branch,Cabang
apps/erpnext/erpnext/hr/report/employee_birthday/employee_birthday.py +20,Department,Departemen
apps/erpnext/erpnext/hr/report/employee_birthday/employee_birthday.py +21,Designation,Penunjukan
apps/erpnext/erpnext/hr/report/employee_birthday/employee_birthday.py +21,Gender,Jenis Kelamin
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +18,No employee found!,Tidak ada karyawan ditemukan!
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +42,Employee Name,Nama Karyawan
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +46,Allocated,
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +47,Taken,
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +48,Balance,
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Absent,
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Present,
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +73,Please select month and year,Silakan pilih bulan dan tahun
apps/erpnext/erpnext/hr/report/monthly_salary_register/monthly_salary_register.py +41,Leave Without Pay,Tinggalkan Tanpa Bayar
apps/erpnext/erpnext/hr/report/monthly_salary_register/monthly_salary_register.py +42,Payment Days,Hari Pembayaran
apps/erpnext/erpnext/hr/report/monthly_salary_register/monthly_salary_register.py +66,No salary slip found for month: ,No salary slip found for month: 
apps/erpnext/erpnext/hr/report/monthly_salary_register/monthly_salary_register.py +67, and year: , and year: 
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +10,Update Cost,Pembaruan Biaya
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +131,You can not change rate if BOM mentioned agianst any item,Anda tidak dapat mengubah tingkat jika BOM disebutkan agianst item
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +111,Please select Price List,Silakan pilih Daftar Harga
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +180,Item {0} does not exist in the system or has expired,Item {0} tidak ada dalam sistem atau telah berakhir
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +191,Operation {0} is repeated in Operations Table,Operasi {0} diulangi dalam Operasi Tabel
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +202,Operation {0} not present in Operations Table,Operasi {0} tidak hadir dalam Operasi Tabel
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +208,Quantity required for Item {0} in row {1},Kuantitas yang dibutuhkan untuk Item {0} berturut-turut {1}
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +215,Item {0} has been entered multiple times against same operation,Barang {0} telah dimasukkan beberapa kali melawan operasi yang sama
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +231,BOM recursion: {0} cannot be parent or child of {2},BOM recursion: {0} tidak bisa menjadi induk atau cabang dari {2}
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +362,Cannot deactivate or cancel BOM as it is linked with other BOMs,
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +422,BOM {0} must be active,
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +425,BOM {0} must be submitted,
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +428,BOM {0} does not belong to Item {1},
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +64,Raw material cannot be same as main Item,Bahan baku tidak bisa sama dengan Butir utama
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_list.html +13,Default,Dfault
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +21,BOM replaced,BOM diganti
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +25,Current BOM and New BOM can not be same,BOM Lancar dan New BOM tidak bisa sama
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +124,Please enter Production Item first,Masukkan Produksi Barang pertama
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +24,Submit this Production Order for further processing.,Kirim Produksi ini Order untuk diproses lebih lanjut.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +27,Complete,Selesai
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +30,Stopped,Terhenti
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +63,Transfer Raw Materials,Mentransfer Bahan Baku
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +65,Update Finished Goods,Barang pembaruan Selesai
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +73,Unstop,Unstop
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +81,Do you really want to stop production order: ,Do you really want to stop production order: 
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +89,Do really want to unstop production order: ,Do really want to unstop production order: 
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +114,Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Kuantitas Diproduksi {0} Tidak dapat lebih besar dari yang direncanakan quanitity {1} dalam Orde Produksi {2}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +120,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 +122,For Warehouse is required before Submit,Untuk Gudang diperlukan sebelum Submit
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +132,Cannot cancel because submitted Stock Entry {0} exists,Tidak bisa membatalkan karena disampaikan Stock entri {0} ada
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +189,No Permission,Tidak ada Izin
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +45,Sales Order {0} is not valid,Sales Order {0} tidak valid
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +77,Cannot produce more Item {0} than Sales Order quantity {1},Tidak dapat menghasilkan lebih Barang {0} daripada kuantitas Sales Order {1}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +85,Production Order status is {0},Status pesanan produksi adalah {0}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +24,Production Item,
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +30,WIP Warehouse,
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_list.html +16,Overdue,
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_list.html +44,Completed,Selesai
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +57,Please enter Item first,Masukkan Barang pertama
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +106,Please enter sales order in the above table,Masukkan order penjualan pada tabel di atas
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +161,Please enter Planned Qty for Item {0} at row {1},Masukkan Planned Qty untuk Item {0} pada baris {1}
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +165,Please enter BOM for Item {0} at row {1},Masukkan BOM untuk Item {0} pada baris {1}
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +171,Incorrect or Inactive BOM {0} for Item {1} at row {2},Salah atau Nonaktif BOM {0} untuk Item {1} pada baris {2}
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +185,{0} created,{0} dibuat
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +187,No Production Orders created,Tidak ada Pesanan Produksi dibuat
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +310,Please enter Warehouse for which Material Request will be raised,Masukkan Gudang yang Material Permintaan akan dibangkitkan
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +404,Material Requests {0} created,Permintaan Material {0} dibuat
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +406,Nothing to request,Tidak ada yang meminta
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +48,Please enter Company,Masukkan Perusahaan
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standard Membeli
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standard Jual
apps/erpnext/erpnext/projects/doctype/project/project.js +11,Tasks,Tugas
apps/erpnext/erpnext/projects/doctype/project/project.js +7,Gantt Chart,Gantt Bagan
apps/erpnext/erpnext/projects/doctype/project/project.py +29,Expected Completion Date can not be less than Project Start Date,Diharapkan Tanggal Penyelesaian tidak bisa kurang dari Tanggal mulai Proyek
apps/erpnext/erpnext/projects/doctype/project/project_list.html +30,% Tasks Completed,
apps/erpnext/erpnext/projects/doctype/project/project_list.html +35,% Milestones Achieved,
apps/erpnext/erpnext/projects/doctype/task/task.py +30,'Expected Start Date' can not be greater than 'Expected End Date',"""Diharapkan Tanggal Mulai 'tidak dapat lebih besar dari' Diharapkan Tanggal End '"
apps/erpnext/erpnext/projects/doctype/task/task.py +33,'Actual Start Date' can not be greater than 'Actual End Date','Sebenarnya Tanggal Mulai' tidak dapat lebih besar dari 'Aktual Tanggal End'
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +54,This Time Log conflicts with {0},Ini Waktu Log bertentangan dengan {0}
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.html +16,hours,
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.html +7,Billable,Dapat ditagih
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +13,Please select Time Logs.,Silakan pilih Sisa log.
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +21,Time Log is not billable,Waktu Log tidak dapat ditagih
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +25,Time Log Status must be Submitted.,Waktu Log Status harus Dikirim.
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +9,Make Time Log Batch,Membuat Waktu Log Batch
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +21,Select Time Logs and Submit to create a new Sales Invoice.,Pilih Waktu Log dan Kirim untuk membuat Faktur Penjualan baru.
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +22,Click on 'Make Sales Invoice' button to create a new Sales Invoice.,Klik 'Buat Sales Invoice' tombol untuk membuat Faktur Penjualan baru.
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +23,This Time Log Batch has been billed.,Batch Waktu Log ini telah ditagih.
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +24,This Time Log Batch has been cancelled.,Batch Waktu Log ini telah dibatalkan.
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +28,Make Sales Invoice,Membuat Sales Invoice
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +33,Time Log {0} must be 'Submitted',Waktu Log {0} harus 'Dikirim'
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +16,From Datetime,
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +16,Time Log,Waktu Log
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +17,Activity Type,Jenis Kegiatan
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +17,Hours,Jam
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +17,Task,Tugas
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +17,To Datetime,
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +18,Task Subject,
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +25,Cost of Purchased Items,
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +25,Project Id,
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Delivered Items,
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Issued Items,
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Project Name,Nama Proyek
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Project Status,
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Value,Nilai Proyek
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Completion Date,Tanggal Penyelesaian
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Start Date,Proyek Tanggal Mulai
apps/erpnext/erpnext/selling/doctype/customer/customer.js +46,Loading...,Memuat...
apps/erpnext/erpnext/selling/doctype/customer/customer.py +159,Credit limit has been crossed for customer {0} {1}/{2},
apps/erpnext/erpnext/selling/doctype/customer/customer.py +165,Please contact to the user who have Sales Master Manager {0} role,
apps/erpnext/erpnext/selling/doctype/customer/customer.py +79,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Kelompok Pelanggan sudah ada dengan nama yang sama, silakan mengubah nama Pelanggan atau mengubah nama Grup Pelanggan"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +100,Please pull items from Delivery Note,Silakan tarik item dari Pengiriman Note
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +50,Serial No is mandatory for Item {0},Serial ada adalah wajib untuk Item {0}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +52,Item {0} is not a serialized Item,Item {0} bukan merupakan Barang serial
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +57,Serial No {0} does not exist,Serial ada {0} tidak ada
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +65,Item {0} with Serial No {1} is already installed,Item {0} dengan Serial No {1} sudah diinstal
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +75,Serial No {0} does not belong to Delivery Note {1},Serial ada {0} bukan milik Pengiriman Note {1}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +96,Installation date cannot be before delivery date for Item {0},Tanggal instalasi tidak bisa sebelum tanggal pengiriman untuk Item {0}
apps/erpnext/erpnext/selling/doctype/lead/lead.js +30,Create Customer,Buat Pelanggan
apps/erpnext/erpnext/selling/doctype/lead/lead.js +32,Create Opportunity,Buat Peluang
apps/erpnext/erpnext/selling/doctype/lead/lead.py +34,Campaign Name is required,Nama Promosi diperlukan
apps/erpnext/erpnext/selling/doctype/lead/lead.py +38,{0} is not a valid email id,{0} bukan id email yang valid
apps/erpnext/erpnext/selling/doctype/lead/lead.py +63,"Email id must be unique, already exists for {0}","Email id harus unik, sudah ada untuk {0}"
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.js +115,Set as Lost,Set as Hilang
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.js +117,Reason for losing,Alasan untuk kehilangan
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.js +119,Update,Perbarui
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.js +132,There were errors.,Ada kesalahan.
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.js +79,Create Quotation,Buat Quotation
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.js +83,Opportunity Lost,Peluang Hilang
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.py +112,Cannot Cancel Opportunity as Quotation Exists,Tidak bisa Batal Peluang sebagai Quotation Exists
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.py +120,"Cannot declare as lost, because Quotation has been made.","Tidak dapat mendeklarasikan sebagai hilang, karena Quotation telah dibuat."
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.py +50,Customer {0} does not exist,Pelanggan {0} tidak ada
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.py +82,Items required,Barang yang dibutuhkan
apps/erpnext/erpnext/selling/doctype/opportunity/opportunity.py +86,Lead must be set if Opportunity is made from Lead,Timbal harus diatur jika Peluang terbuat dari Timbal
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +29,Make Sales Order,Membuat Sales Order
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +39,From Opportunity,Dari Peluang
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +92,Please select a value for {0} quotation_to {1},Silakan pilih nilai untuk {0} quotation_to {1}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +176,Please create Customer from Lead {0},Silakan membuat pelanggan dari Lead {0}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +35,Item {0} with same description entered twice,Item {0} dengan deskripsi yang sama dimasukkan dua kali
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +48,Item {0} must be Service Item,Item {0} harus Layanan Barang
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +55,Item {0} must be Sales Item,Item {0} harus Penjualan Barang
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +75,Cannot set as Lost as Sales Order is made.,Tidak dapat ditetapkan sebagai Hilang sebagai Sales Order dibuat.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +79,Please enter item details,Masukkan detil item
apps/erpnext/erpnext/selling/doctype/sales_bom/sales_bom.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Silakan pilih Barang di mana ""Apakah Stock Item"" adalah ""Tidak"" dan ""Apakah Penjualan Item"" adalah ""Ya"" dan tidak ada Penjualan BOM lainnya"
apps/erpnext/erpnext/selling/doctype/sales_bom/sales_bom.py +27,Parent Item {0} must be not Stock Item and must be a Sales Item,Induk Barang {0} harus tidak Stock Barang dan harus Item Penjualan
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +165,Are you sure you want to STOP ,Apakah anda yakin untuk berhenti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +180,Are you sure you want to UNSTOP ,Apakah anda yakin untuk batal berhenti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +23,% Delivered,Disampaikan%
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +34,Make ,Make 
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +34,Material Request,Permintaan Material
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +50,Make Maint. Visit,Buat Maint. Kunjungan
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +52,Make Maint. Schedule,Buat Maint. Jadwal
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +66,From Quotation,Dari Quotation
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +149,Quotation {0} is cancelled,Quotation {0} dibatalkan
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Stopped order cannot be cancelled. Unstop to cancel.,Agar Berhenti tidak dapat dibatalkan. Unstop untuk membatalkan.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +181,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Catatan pengiriman {0} harus dibatalkan sebelum membatalkan Sales Order ini
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +189,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 +196,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Jadwal pemeliharaan {0} harus dibatalkan sebelum membatalkan Sales Order ini
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +202,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 +208,Production Order {0} must be cancelled before cancelling this Sales Order,Pesanan produksi {0} harus dibatalkan sebelum membatalkan Sales Order ini
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +221,{0} {1} status is Stopped,{0} Status {1} adalah Berhenti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +227,{0} {1} status is Unstopped,{0} {1} status unstopped
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +28,Expected Delivery Date cannot be before Sales Order Date,Diharapkan Pengiriman Tanggal tidak bisa sebelum Sales Order Tanggal
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +33,Expected Delivery Date cannot be before Purchase Order Date,Diharapkan Pengiriman Tanggal tidak bisa sebelum Purchase Order Tanggal
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +40,Warning: Sales Order {0} already exists against same Purchase Order number,Peringatan: Sales Order {0} sudah ada terhadap nomor Purchase Order yang sama
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +51,Reserved warehouse required for stock item {0},Reserved gudang diperlukan untuk item saham {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +54,Item {0} has been entered twice,Item {0} telah dimasukkan dua kali
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +75,Quotation {0} not of type {1},Quotation {0} bukan dari jenis {1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +82,Please enter 'Expected Delivery Date',Masukkan 'Diharapkan Pengiriman Tanggal'
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_list.html +36,Delivered,Disampaikan
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +66,Receiver List is empty. Please create Receiver List,Receiver List kosong. Silakan membuat Receiver List
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +73,Please enter message before sending,Masukkan pesan sebelum mengirimnya
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +33,Customer Group / Customer,Kelompok Pelanggan / Pelanggan
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +65,Territory / Customer,Wilayah / Pelanggan
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +99,Quantity,Kuantitas
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +99,Value,Nilai
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +115,New {0} Name,
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +116,Group Node,
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +117,Further nodes can be only created under 'Group' type nodes,Node lebih lanjut dapat hanya dibuat di bawah tipe node 'Grup'
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +123,Please enter Employee Id of this sales parson,Masukkan Id Karyawan pendeta penjualan ini
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +128,New {0},New {0}
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +19,Click on a link to get options to expand get options ,Click on a link to get options to expand get options 
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +47,{0} Tree,
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +39,No Data,
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +56,Year,Tahun
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +38,Credit Limit,Batas Kredit
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Credit Balance,
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.js +8,Days Since Last Order,Hari Sejak Orde terakhir
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +14,'Days Since Last Order' must be greater than or equal to zero,'Hari Sejak Orde terakhir' harus lebih besar dari atau sama dengan nol
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +57,Number of Order,
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +58,Total Order Value,
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +59,Total Order Considered,
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +60,Last Order Amount,
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +61,Last Sales Order Date,
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +22,Target On,Sasaran On
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.js +14,Document Type,Jenis Dokumen
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +26,Please select the document type first,Silakan pilih jenis dokumen pertama
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Contribution %,
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +33,Contribution Amount,
apps/erpnext/erpnext/selling/sales_common.js +191,[Error],[Kesalahan]
apps/erpnext/erpnext/selling/sales_common.js +431,cannot be greater than 100,tidak dapat lebih besar dari 100
apps/erpnext/erpnext/selling/sales_common.js +485,"For 'Sales BOM' 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 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Untuk 'Penjualan BOM' item, Gudang, Serial No dan Batch ada akan dipertimbangkan dari meja 'Daftar Packing'. Jika Gudang dan Batch ada yang sama untuk semua item kemasan untuk setiap 'Penjualan BOM' item, nilai-nilai dapat dimasukkan dalam tabel Barang utama, nilai akan disalin ke meja 'Daftar Packing'."
apps/erpnext/erpnext/selling/sales_common.js +600,Cost Center For Item with Item Code ',
apps/erpnext/erpnext/selling/sales_common.js +80,Please enter Item Code to get batch no,Masukkan Item Code untuk mendapatkan bets tidak
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/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Dapat disetujui oleh {0}
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/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Masukkan Menyetujui Peran atau Menyetujui Pengguna
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
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/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Tidak dapat mengatur otorisasi atas dasar Diskon untuk {0}
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Diskon harus kurang dari 100
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Pelanggan yang dibutuhkan untuk 'Customerwise Diskon'
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_dropbox.py +121,Please install dropbox python module,Silakan instal modul python dropbox
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_dropbox.py +124,Please set Dropbox access keys in your site config,Silakan set tombol akses Dropbox di situs config Anda
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_googledrive.py +120,Please set Google Drive access keys in {0},Silakan set tombol akses Google Drive di {0}
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_googledrive.py +147,Updated,Diperbarui
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +10,You can start by selecting backup frequency and granting access for sync,Anda dapat memulai dengan memilih frekuensi backup dan memberikan akses untuk sinkronisasi
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +13,Dropbox,Dropbox
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +14,Google Drive,Google Drive
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +27,Backups will be uploaded to,Backup akan di-upload ke
apps/erpnext/erpnext/setup/doctype/company/company.py +140,Main,Utama
apps/erpnext/erpnext/setup/doctype/company/company.py +182,"Sorry, companies cannot be merged","Maaf, perusahaan tidak dapat digabungkan"
apps/erpnext/erpnext/setup/doctype/company/company.py +31,Abbreviation cannot have more than 5 characters,Singkatan tidak dapat melebihi 5 karakter
apps/erpnext/erpnext/setup/doctype/company/company.py +37,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Tidak dapat mengubah mata uang default perusahaan, karena ada transaksi yang ada. Transaksi harus dibatalkan untuk mengubah mata uang default."
apps/erpnext/erpnext/setup/doctype/company/company.py +48,Account {0} does not belong to company: {1},Akun {0} bukan milik perusahaan: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +71,Finished Goods,Barang Jadi
apps/erpnext/erpnext/setup/doctype/company/company.py +71,Stores,Toko
apps/erpnext/erpnext/setup/doctype/company/company.py +71,Work In Progress,Bekerja In Progress
apps/erpnext/erpnext/setup/doctype/company/company.py +85,Please select Chart of Accounts,
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +20,From Currency and To Currency cannot be same,Dari Mata dan Mata Uang Untuk tidak bisa sama
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +14,This is a root customer group and cannot be edited.,Ini adalah kelompok pelanggan akar dan tidak dapat diedit.
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,An Customer exists with same name,Sebuah Pelanggan ada dengan nama yang sama
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +19,Email Digest: ,Email Digest: 
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +32,Send Now,Kirim sekarang
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +41,Message Sent,Pesan Terkirim
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +59,Add/Remove Recipients,Tambah / Hapus Penerima
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/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/setup/doctype/email_digest/email_digest.js +76,disabled user,
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +84,{0} Recipients,
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Lihat Sekarang
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +131,There were no updates in the items selected for this digest.,
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +139,No Updates For,
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +303,All Day,Semua Hari
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +309,Upcoming Calendar Events (max 10),
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +311,Calendar Events,Acara
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +327,assigned by,ditugaskan oleh
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +17,This is a root item group and cannot be edited.,Ini adalah kelompok barang akar dan tidak dapat diedit.
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +39,"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 barang atau mengubah nama item"
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +117,Series {0} already used in {1},Seri {0} sudah digunakan dalam {1}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +122,"Special Characters except ""-"" and ""/"" not allowed in naming series","Karakter khusus kecuali ""-"" dan ""/"" tidak diperbolehkan dalam penamaan seri"
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +144,Series Updated Successfully,Seri Diperbarui Berhasil
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +146,Please select prefix first,Silakan pilih awalan pertama
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +53,Series Updated,Seri Diperbarui
apps/erpnext/erpnext/setup/doctype/notification_control/notification_control.py +20,Message updated,Pesan diperbarui
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +14,This is a root sales person and cannot be edited.,Ini adalah orang penjualan akar dan tidak dapat diedit.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Entah Target qty atau jumlah target adalah wajib.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +26,User ID not set for Employee {0},User ID tidak ditetapkan untuk Karyawan {0}
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +25,Please enter valid mobile nos,Masukkan nos ponsel yang valid
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +69,Please Update SMS Settings,Silahkan Perbarui Pengaturan SMS
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Tidak ada yang mengedit.
apps/erpnext/erpnext/setup/doctype/territory/territory.js +14,This is a root territory and cannot be edited.,Ini adalah wilayah akar dan tidak dapat diedit.
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/setup/page/setup_wizard/default_website.py +28,This is an example website auto-generated from ERPNext,Ini adalah situs contoh auto-dihasilkan dari ERPNext
apps/erpnext/erpnext/setup/page/setup_wizard/default_website.py +62,Products,Produk
apps/erpnext/erpnext/setup/page/setup_wizard/default_website.py +80,General,Umum
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +100,Non Profit,Non Profit
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +101,Government,pemerintahan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +105,Local,[Daerah
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +107,Electrical,Listrik
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +108,Hardware,Perangkat keras
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +109,Pharmaceutical,Farmasi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +110,Distributor,Distributor
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +113,Sales Team,Tim Penjualan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +116,Unit,Satuan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +117,Box,Kotak
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +118,Kg,Kg
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +119,Nos,Nos
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +120,Pair,Pasangkan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +121,Set,Tetapkan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +122,Hour,Jam
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +123,Minute,Menit
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +126,Cheque,Cek
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +128,Credit Card,Kartu Kredit
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +129,Wire Transfer,Transfer
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +130,Bank Draft,Bank Draft
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +133,Planning,Perencanaan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +134,Research,Penelitian
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +135,Proposal Writing,Penulisan Proposal
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +136,Execution,Eksekusi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +137,Communication,Komunikasi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +140,Accounting,Akuntansi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +141,Advertising,Periklanan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +142,Aerospace,Aerospace
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +143,Agriculture,Pertanian
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +144,Airline,Maskapai Penerbangan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +145,Apparel & Accessories,Pakaian & Aksesoris
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +146,Automotive,Otomotif
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +147,Banking,Perbankan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +148,Biotechnology,Bioteknologi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +149,Broadcasting,Penyiaran
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +150,Brokerage,Memperantarai
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +151,Chemical,Kimia
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +152,Computer,Komputer
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +153,Consulting,Konsultasi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +154,Consumer Products,Produk Konsumen
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +155,Cosmetics,Kosmetik
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +156,Defense,Pertahanan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +157,Department Stores,Departmen Store
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +158,Education,Pendidikan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +159,Electronics,Elektronik
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +160,Energy,Energi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +161,Entertainment & Leisure,Hiburan & Kenyamanan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +162,Executive Search,Pencarian eksekutif
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +163,Financial Services,Jasa Keuangan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +164,"Food, Beverage & Tobacco","Makanan, Minuman dan Tembakau"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +165,Grocery,Toko bahan makanan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +166,Health Care,Perawatan Kesehatan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +167,Internet Publishing,Penerbitan Internet
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +168,Investment Banking,Perbankan Investasi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +17,All Item Groups,Semua Grup Barang/Item
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +170,Manufacturing,Manufaktur
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +171,Motion Picture & Video,Motion Picture & Video
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +172,Music,Musik
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +173,Newspaper Publishers,Koran Publishers
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +174,Online Auctions,Lelang Online
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +175,Pension Funds,Dana pensiun
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +176,Pharmaceuticals,Farmasi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +177,Private Equity,Private Equity
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +178,Publishing,Penerbitan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +179,Real Estate,Real Estate
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +180,Retail & Wholesale,Retail & Grosir
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +181,Securities & Commodity Exchanges,Efek & Bursa Komoditi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +183,Soap & Detergent,Sabun & Deterjen
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +184,Software,Perangkat lunak
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +185,Sports,Olahraga
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +186,Technology,Teknologi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +187,Telecommunications,Telekomunikasi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +188,Television,Televisi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +189,Transportation,Transportasi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +190,Venture Capital,Modal Ventura
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +21,Raw Material,Bahan Baku
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +23,Services,Layanan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +25,Sub Assemblies,Sub Assemblies
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +27,Consumable,Consumable
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +31,Income Tax,Pajak Penghasilan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +34,Basic,Dasar
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +37,Calls,Panggilan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +38,Food,Makanan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +39,Medical,Medis
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +40,Others,Lainnya
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +41,Travel,Perjalanan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +44,Casual Leave,Santai Cuti
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +45,Compensatory Off,Kompensasi Off
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +46,Sick Leave,Cuti Sakit
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +47,Privilege Leave,Privilege Cuti
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +51,Full-time,Full-time
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +52,Part-time,Part-time
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +53,Probation,Percobaan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +54,Contract,Kontrak
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +55,Commission,Komisi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +56,Piecework,Pekerjaan yg dibayar menurut hasil yg dikerjakan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +57,Intern,Menginternir
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +58,Apprentice,Magang
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +62,Marketing,Pemasaran
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +64,Purchase,Pembelian
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +65,Operations,Operasi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +66,Production,Produksi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +67,Dispatch,Pengiriman
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +68,Customer Service,Layanan Pelanggan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +70,Management,Manajemen
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +71,Quality Management,Manajemen Kualitas
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +72,Research & Development,Penelitian & Pengembangan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +73,Legal,Hukum
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +77,Manager,Manajer
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +78,Analyst,Analis
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +79,Engineer,Insinyur
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +80,Accountant,Akuntan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +81,Secretary,Sekretaris
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +82,Associate,Rekan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +83,Administrative Officer,Petugas Administrasi
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +84,Business Development Manager,Business Development Manager
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +85,HR Manager,HR Manager
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +86,Project Manager,Manager Project
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +87,Head of Marketing and Sales,Kepala Pemasaran dan Penjualan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +88,Software Developer,Software Developer
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +89,Designer,Perancang
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +90,Assistant,Asisten
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +91,Researcher,Peneliti
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +94,All Territories,Semua Wilayah
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +97,All Customer Groups,Semua Grup Pelanggan
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +98,Individual,Individu
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +99,Commercial,Komersial
apps/erpnext/erpnext/setup/page/setup_wizard/sample_home_page.html +14,Awesome Services,Layanan mengagumkan
apps/erpnext/erpnext/setup/page/setup_wizard/sample_home_page.html +3,Awesome Products,Produk Mengagumkan
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +101,Your Login Id,Login Id Anda
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +102,Password,Kata sandi
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +105,Attach Your Picture,Pasang Gambar Anda
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +107,The first user will become the System Manager (you can change that later).,Pengguna pertama akan menjadi System Manager (Anda dapat mengubah nanti).
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +130,"Country, Timezone and Currency","Country, Timezone dan Mata Uang"
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +133,Country,Negara
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +135,Default Currency,Currency Default
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +137,Time Zone,"Zona Waktu: GMT +2; CET +1, dan EST (AS-Timur) +7"
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +142,Select your home country and check the timezone and currency.,Pilih negara asal Anda dan memeriksa zona waktu dan mata uang.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +192,The Organization,Organisasi
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +195,Company Name,Company Name
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +196,"e.g. ""My Company LLC""","misalnya ""My Company LLC """
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +197,Company Abbreviation,Singkatan Perusahaan
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +198,Max 5 characters,Max 5 karakter
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +198,"e.g. ""MC""","misalnya ""MC """
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +199,Financial Year Start Date,Tahun Buku Tanggal mulai
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +200,Your financial year begins on,Tahun pembukuan Anda dimulai
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +201,Financial Year End Date,Tahun Keuangan Akhir Tanggal
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +202,Your financial year ends on,Tahun keuangan Anda berakhir pada
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +203,What does it do?,Apa gunanya?
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +204,"e.g. ""Build tools for builders""","misalnya ""Membangun alat untuk pembangun """
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +206,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/setup/page/setup_wizard/setup_wizard.js +22,Login with your new User ID,Login dengan User ID baru Anda
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +234,Logo and Letter Heads,Logo dan Surat Kepala
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +235,Upload your letter head and logo - you can edit them later.,Upload kop surat dan logo - Anda dapat mengedit mereka nanti.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +238,Attach Letterhead,Lampirkan Surat
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +239,Keep it web friendly 900px (w) by 100px (h),Simpan web 900px ramah (w) oleh 100px (h)
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +242,Attach Logo,Pasang Logo
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +250,Add Taxes,Tambahkan Pajak
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +251,"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Daftar kepala pajak Anda (misalnya PPN, Cukai, mereka harus memiliki nama yang unik) dan tingkat standar mereka. Ini akan membuat template standar, yang dapat Anda edit dan menambahkannya kemudian."
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +257,Tax,PPN
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +258,e.g. VAT,misalnya PPN
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +260,Rate (%),Rate (%)
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +260,e.g. 5,misalnya 5
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +270,Your Customers,Pelanggan Anda
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +271,List a few of your customers. They could be organizations or individuals.,Daftar beberapa pelanggan Anda. Mereka bisa menjadi organisasi atau individu.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +281,Contact Name,Nama Kontak
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +291,Your Suppliers,Pemasok Anda
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +292,List a few of your suppliers. They could be organizations or individuals.,Daftar beberapa pemasok Anda. Mereka bisa menjadi organisasi atau individu.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +312,Your Products or Services,Produk atau Jasa
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +313,"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Daftar produk atau jasa yang Anda membeli atau menjual. Pastikan untuk memeriksa Grup Barang, Satuan Ukur dan properti lainnya ketika Anda mulai."
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +321,A Product or Service,Produk atau Jasa
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +322,We sell this Item,Kami menjual item ini
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +323,We buy this Item,Kami membeli item ini
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +325,Group,Grup
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +331,Attach Image,Pasang Gambar
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +40,Welcome,Selamat Datang
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +42,ERPNext Setup,ERPNext Pengaturan
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +44,Welcome to ERPNext. Over the next few minutes we will help you setup your ERPNext account. Try and fill in as much information as you have even if it takes a bit longer. It will save you a lot of time later. Good Luck!,Selamat Datang di ERPNext. Selama beberapa menit berikutnya kami akan membantu Anda setup account ERPNext Anda. Cobalah dan mengisi sebanyak mungkin informasi sebagai Anda memiliki bahkan jika dibutuhkan sedikit lebih lama. Ini akan menghemat banyak waktu. Selamat!
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +461,Previous,Sebelumnya
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +462,Next,Berikutnya
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +463,Complete Setup,Pengaturan Lengkap
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +47,Setting up...,Menyiapkan ...
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +49,Sit tight while your system is being setup. This may take a few moments.,Duduk diam sementara sistem anda sedang setup. Ini mungkin memerlukan beberapa saat.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +52,Setup Complete,Pengaturan Selesai
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +54,Your setup is complete. Refreshing...,Setup Anda selesai. Refreshing ...
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +59,Select Your Language,Pilih Bahasa Anda
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +63,Language,Bahasa
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +70,Welcome to ERPNext. Please select your language to begin the Setup Wizard.,Selamat Datang di ERPNext. Silahkan pilih bahasa Anda untuk memulai Setup Wizard.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +93,The First User: You,Pengguna Pertama: Anda
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +96,First Name,Nama Depan
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +98,Last Name,Nama Belakang
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +22,Setup Already Complete!!,Pengaturan Sudah Selesai!!
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +390,Standard,Standar
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +423,Rest Of The World,Istirahat Of The World
apps/erpnext/erpnext/setup/utils.py +14,Please specify Default Currency in Company Master and Global Defaults,Silakan tentukan Currency Default dalam Perseroan Guru dan Default global
apps/erpnext/erpnext/shopping_cart/__init__.py +68,{0} cannot be purchased using Shopping Cart,
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +113,Missing Currency Exchange Rates for {0},
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +166,You need to enable Shopping Cart,
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +40,{0} {1} has a common territory {2},
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +52,Please specify a Price List which is valid for Territory,
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +89,Please specify currency in Company,
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +99,Currency is required for Price List {0},
apps/erpnext/erpnext/stock/doctype/batch/batch.py +17,The selected item cannot have Batch,
apps/erpnext/erpnext/stock/doctype/batch/batch_list.html +11,Expired,
apps/erpnext/erpnext/stock/doctype/batch/batch_list.html +16,Expiry,
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +32,Make Installation Note,Membuat Instalasi Note
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +41,Make Packing Slip,Membuat Packing Slip
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +159,Note: Item {0} entered multiple times,Catatan: Barang {0} masuk beberapa kali
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +172,Warehouse required for stock Item {0},Gudang diperlukan untuk stok Barang {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +230,Packed quantity must equal quantity for Item {0} in row {1},Dikemas kuantitas harus sama kuantitas untuk Item {0} berturut-turut {1}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +241,Sales Invoice {0} has already been submitted,Faktur Penjualan {0} telah disampaikan
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +248,Installation Note {0} has already been submitted,Instalasi Catatan {0} telah disampaikan
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +261,Packing Slip(s) cancelled,Packing slip (s) dibatalkan
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +281,Reserved Warehouse is missing in Sales Order,Gudang Reserved hilang di Sales Order
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +316,All these items have already been invoiced,Semua barang-barang tersebut telah ditagih
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +96,Sales Order required for Item {0},Sales Order yang diperlukan untuk Item {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.html +23,% Installed,% Terpasang
apps/erpnext/erpnext/stock/doctype/item/item.js +13,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,
apps/erpnext/erpnext/stock/doctype/item/item.js +14,Show Variants,
apps/erpnext/erpnext/stock/doctype/item/item.js +155,"Please select an ""Image"" first","Harap pilih ""Gambar"" pertama"
apps/erpnext/erpnext/stock/doctype/item/item.js +172,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Berat disebutkan, \n Harap menyebutkan ""Berat UOM"" terlalu"
apps/erpnext/erpnext/stock/doctype/item/item.js +19,This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,
apps/erpnext/erpnext/stock/doctype/item/item.js +204,You may need to update: {0},Anda mungkin perlu memperbarui: {0}
apps/erpnext/erpnext/stock/doctype/item/item.js +76,Add / Edit Prices,
apps/erpnext/erpnext/stock/doctype/item/item.py +123,"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.","Standar Unit Ukur tidak dapat diubah secara langsung karena Anda telah membuat beberapa transaksi (s) dengan UOM lain. Untuk mengubah UOM default, gunakan 'UOM Ganti Utilitas' alat di bawah modul Stock."
apps/erpnext/erpnext/stock/doctype/item/item.py +134,Item Template cannot have stock and varaiants. Please remove stock from warehouses {0},
apps/erpnext/erpnext/stock/doctype/item/item.py +142,Item cannot be a variant of a variant,
apps/erpnext/erpnext/stock/doctype/item/item.py +148,{0} {1} is entered more than once in Item Variants table,
apps/erpnext/erpnext/stock/doctype/item/item.py +175,Item Variants {0} created,
apps/erpnext/erpnext/stock/doctype/item/item.py +178,Item Variants {0} updated,
apps/erpnext/erpnext/stock/doctype/item/item.py +181,Item Variants {0} deleted,
apps/erpnext/erpnext/stock/doctype/item/item.py +269,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/stock/doctype/item/item.py +274,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 +278,"As Production Order can be made for this item, it must be a stock item.","Seperti Orde Produksi dapat dibuat untuk item ini, itu harus menjadi barang saham."
apps/erpnext/erpnext/stock/doctype/item/item.py +281,'Has Serial No' can not be 'Yes' for non-stock item,"""Apakah ada Serial 'tidak bisa' Ya 'untuk item non-saham"
apps/erpnext/erpnext/stock/doctype/item/item.py +291,Default BOM must be for this item or its template,
apps/erpnext/erpnext/stock/doctype/item/item.py +300,"Item must be a purchase item, as it is present in one or many Active BOMs","Item harus item pembelian, karena hadir dalam satu atau banyak BOMs Aktif"
apps/erpnext/erpnext/stock/doctype/item/item.py +317,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 +320,{0} entered twice in Item Tax,{0} masuk dua kali dalam Pajak Barang
apps/erpnext/erpnext/stock/doctype/item/item.py +329,Barcode {0} already used in Item {1},Barcode {0} sudah digunakan dalam Butir {1}
apps/erpnext/erpnext/stock/doctype/item/item.py +33,Item Code is mandatory because Item is not automatically numbered,Item Code adalah wajib karena Item tidak secara otomatis nomor
apps/erpnext/erpnext/stock/doctype/item/item.py +341,"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Has Batch No', 'Is Stock Item' and 'Valuation Method'",
apps/erpnext/erpnext/stock/doctype/item/item.py +351,"To set reorder level, item must be a Purchase Item",
apps/erpnext/erpnext/stock/doctype/item/item.py +359,Row {0}: An Reorder entry already exists for this warehouse {1},
apps/erpnext/erpnext/stock/doctype/item/item.py +370,"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 barang"
apps/erpnext/erpnext/stock/doctype/item/item.py +391,Item {0} does not exist,Item {0} tidak ada
apps/erpnext/erpnext/stock/doctype/item/item.py +396,"To merge, following properties must be same for both items","Untuk bergabung, sifat berikut harus sama untuk kedua item"
apps/erpnext/erpnext/stock/doctype/item/item.py +41,Please enter default Unit of Measure,Masukkan Satuan default Ukur
apps/erpnext/erpnext/stock/doctype/item/item.py +442,Item {0} has reached its end of life on {1},Item {0} telah mencapai akhir hidupnya pada {1}
apps/erpnext/erpnext/stock/doctype/item/item.py +450,Item {0} is not a stock Item,Item {0} bukan merupakan saham Barang
apps/erpnext/erpnext/stock/doctype/item/item.py +459,Item {0} is cancelled,Item {0} dibatalkan
apps/erpnext/erpnext/stock/doctype/item/item.py +83,Default Warehouse is mandatory for stock Item.,Standar Warehouse adalah wajib bagi saham Barang.
apps/erpnext/erpnext/stock/doctype/item/item_list.html +10,Stock Item,
apps/erpnext/erpnext/stock/doctype/item/item_list.html +17,Sales Item,
apps/erpnext/erpnext/stock/doctype/item/item_list.html +24,Purchase Item,
apps/erpnext/erpnext/stock/doctype/item/item_list.html +31,Manufactured Item,
apps/erpnext/erpnext/stock/doctype/item/item_list.html +38,Shown in Website,
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +14,{0} must appear only once,
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +23,Item {0} not found,Item {0} tidak ditemukan
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +34,Item {0} appears multiple times in Price List {1},Item {0} muncul beberapa kali dalam Daftar Harga {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +13,Please enter company first,Silahkan masukkan perusahaan pertama
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +47,Charges will be distributed proportionately based on item amount,
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +50,Remove item if charges is not applicable to that item,
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +53,Charges are updated in Purchase Receipt against each item,
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +56,Item valuation rate is recalculated considering landed cost voucher amount,
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +59,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +71,Please enter Purchase Receipt first,
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +48,Please enter Purchase Receipts,
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +51,Please enter Taxes and Charges,
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +57,Purchase Receipt must be submitted,
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item must be added using 'Get Items from Purchase Receipts' button,
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +65,Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +107,Fetch exploded BOM (including sub-assemblies),Fetch meledak BOM (termasuk sub-rakitan)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +175,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 +180,Do you really want to STOP this Material Request?,Apakah Anda benar-benar ingin BERHENTI Permintaan Bahan ini?
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +191,Do you really want to UNSTOP this Material Request?,Apakah Anda benar-benar ingin unstop Permintaan Bahan ini?
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +31,Fulfilled,Terpenuhi
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +35,Get Items from BOM,Dapatkan item dari BOM
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +41,Make Supplier Quotation,Membuat Pemasok Quotation
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +46,Transfer Material,Material Transfer
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +50,Issue Material,
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +83,Unstop Material Request,Unstop Material Permintaan
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +102,Status updated to {0},Status diperbarui ke {0}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +55,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}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +60,Expected Date cannot be before Material Request Date,Diharapkan Tanggal tidak bisa sebelum Material Request Tanggal
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.html +25,Ordered,Ordered
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +48,Case No. cannot be 0,Kasus No tidak bisa 0
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +54,'To Case No.' cannot be less than 'From Case No.','Untuk Kasus No' tidak bisa kurang dari 'Dari Kasus No'
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +75,You have entered duplicate items. Please rectify and try again.,Anda telah memasukkan item yang sama. Harap diperbaiki dan coba lagi.
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +81,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Kuantitas tidak valid untuk item {0}. Jumlah harus lebih besar dari 0.
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +97,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 untuk item akan menyebabkan salah (Total) Nilai Berat Bersih. Pastikan Berat Bersih dari setiap item di UOM sama.
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +121,Quantity for Item {0} must be less than {1},Kuantitas untuk Item {0} harus kurang dari {1}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +35,Delivery Note {0} must not be submitted,Pengiriman Note {0} tidak boleh disampaikan
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +40,No Items to pack,Tidak ada item untuk berkemas
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +47,Please specify a valid 'From Case No.',Silakan tentukan valid 'Dari Kasus No'
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +65,Case No(s) already in use. Try from Case No {0},Kasus ada (s) sudah digunakan. Coba dari Case ada {0}
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/stock/doctype/purchase_receipt/purchase_receipt.js +138,Please enter Item Code.,Masukkan Item Code.
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +19,Make Purchase Invoice,Membuat Purchase Invoice
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +61,Error: {0} > {1},Kesalahan: {0}> {1}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +100,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/stock/doctype/purchase_receipt/purchase_receipt.py +130,Purchase Order number required for Item {0},Nomor Purchase Order yang diperlukan untuk Item {0}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +202,Quality Inspection required for Item {0},Kualitas Inspeksi diperlukan untuk Item {0}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +296,Accounting Entry for Stock,
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +397,All items have already been invoiced,Semua Barang telah tertagih
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +84,Rejected Warehouse is mandatory against regected item,Gudang Ditolak adalah wajib terhadap barang regected
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_list.html +11,Subcontracted,
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.js +22,Set Status as Available,Set Status sebagai Tersedia
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +166,Delivered Serial No {0} cannot be deleted,Disampaikan Serial ada {0} tidak dapat dihapus
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +168,"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Tidak dapat menghapus Serial ada {0} di saham. Pertama menghapus dari saham, kemudian hapus."
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +172,"Sorry, Serial Nos cannot be merged","Maaf, Serial Nos tidak dapat digabungkan"
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +203,Item {0} is not setup for Serial Nos. Column must be blank,Barang {0} tidak setup untuk Serial Nos Kolom harus kosong
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +209,Serial No {0} quantity {1} cannot be a fraction,Serial ada {0} kuantitas {1} tak bisa menjadi pecahan
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +212,{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} Serial Number diperlukan untuk Item {0}. Hanya {0} disediakan.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +216,Duplicate Serial No entered for Item {0},Gandakan Serial ada dimasukkan untuk Item {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +223,Serial No {0} does not belong to Item {1},Serial ada {0} bukan milik Barang {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} has already been received,Serial ada {0} telah diterima
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} does not belong to Warehouse {1},Serial ada {0} bukan milik Gudang {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +237,Serial No {0} status must be 'Available' to Deliver,Tidak ada Status {0} Serial harus 'Tersedia' untuk Menyampaikan
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +242,Serial No {0} not in stock,Serial ada {0} bukan dalam stok
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +244,Serial Nos Required for Serialized Item {0},Serial Nos Diperlukan untuk Serial Barang {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +292,Serial No {0} created,Serial ada {0} dibuat
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +30,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Baru Serial ada tidak dapat memiliki Gudang. Gudang harus diatur oleh Bursa Masuk atau Penerimaan Pembelian
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +58,Item Code cannot be changed for Serial No.,Item Code tidak dapat diubah untuk Serial Number
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +61,Warehouse cannot be changed for Serial No.,Gudang tidak dapat diubah untuk Serial Number
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +70,Item {0} is not setup for Serial Nos. Check Item master,Barang {0} tidak setup untuk Serial Nos Periksa Barang induk
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +172,You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,Anda tidak dapat memasukkan kedua Delivery Note ada dan Faktur Penjualan No Masukkan salah satu.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +176,Please enter Delivery Note No or Sales Invoice No to proceed,Masukkan Pengiriman Note ada atau Faktur Penjualan Tidak untuk melanjutkan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +191,Please enter Purchase Receipt No to proceed,Masukkan Penerimaan Pembelian ada untuk melanjutkan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +199,Make Excise Invoice,Membuat Cukai Faktur
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +74,Make Credit Note,Membuat Nota Kredit
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +78,Make Debit Note,Membuat Debit Note
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +115,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Silakan tentukan Serial ada untuk Item {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +141,Atleast one warehouse is mandatory,Setidaknya satu gudang adalah wajib
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/stock_entry/stock_entry.py +147,Target warehouse is mandatory for row {0},Target gudang adalah wajib untuk baris {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +158,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,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 +172,Production order number is mandatory for stock entry purpose manufacture,
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +197,Stock Entries already created for Production Order ,Stock Entries already created for Production Order 
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +210,Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Total penilaian untuk diproduksi atau dikemas ulang item (s) tidak bisa kurang dari penilaian total bahan baku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +221,Posting date and posting time is mandatory,Tanggal posting dan posting waktu adalah wajib
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +242,"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
					Available Qty: {4}, Transfer Qty: {5}",
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +304,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Jumlah berturut-turut {0} ({1}) harus sama dengan jumlah yang diproduksi {2}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +313,{0} {1} must be submitted,{0} {1} harus diserahkan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +318,'Update Stock' for Sales Invoice {0} must be set,'Update Stock' untuk Sales Invoice {0} harus diatur
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +327,Posting timestamp must be after {0},Posting timestamp harus setelah {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +335,Item {0} does not exist in {1} {2},Item {0} tidak ada di {1} {2}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +345,Item {0} has already been returned,Item {0} telah dikembalikan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +347,Cannot return more than {0} for Item {1},Tidak dapat kembali lebih dari {0} untuk Item {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +388,Production Order {0} must be submitted,Pesanan produksi {0} harus diserahkan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +391,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 +416,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 +442,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 +499,Stock Entry against Production Order must be for 'Material Transfer' or 'Manufacture',
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +502,Manufacturing Quantity is mandatory,Manufaktur Kuantitas adalah wajib
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +575,All items have already been transferred for this Production Order.,
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +578,Pending Items {0} updated,Pending Items {0} diperbarui
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +631,Item or Warehouse for row {0} does not match Material Request,Item atau Gudang untuk baris {0} Material tidak cocok Permintaan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +85,Purpose must be one of {0},Tujuan harus menjadi salah satu {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,{0} is not a stock Item,{0} bukan merupakan saham Barang
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +43,Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},Saldo negatif dalam Batch {0} untuk Item {1} di Gudang {2} pada {3} {4}
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +54,Actual Qty is mandatory,
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +62,Item {0} must be a stock Item,Item {0} harus stok Barang
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +72,{0} is not a valid Batch Number for Item {1},{0} tidak Nomor Batch berlaku untuk Item {1}
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +75,Stock cannot exist for Item {0} since has variants,
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +86,Stock transactions before {0} are frozen,Transaksi saham sebelum {0} dibekukan
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +93,Not allowed to update stock transactions older than {0},Tidak diizinkan untuk memperbarui transaksi saham lebih tua dari {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +124,Download Reconcilation Data,Ambil rekonsiliasi data
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +125,Stock Reconcilation Data,Stock rekonsiliasi data
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +62,You can submit this Stock Reconciliation.,Anda bisa mengirimkan ini Stock Rekonsiliasi.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +64,"Download the Template, fill appropriate data and attach the modified file.","Unduh Template, isi data yang tepat dan melampirkan file dimodifikasi."
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +67,Cancelling this Stock Reconciliation will nullify its effect.,Membatalkan ini Stock Rekonsiliasi akan meniadakan efeknya.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +79,Download Template,Download Template
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +80,Stock Reconcilation Template,Stock rekonsiliasi Template
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +81,Stock Reconciliation,Stock Rekonsiliasi
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +83,"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.","Stock Rekonsiliasi dapat digunakan untuk memperbarui saham pada tanggal tertentu, biasanya sesuai persediaan fisik."
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +84,"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Ketika disampaikan, sistem menciptakan entri perbedaan untuk mengatur saham yang diberikan dan penilaian pada tanggal ini."
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +85,It can also be used to create opening stock entries and to fix stock value.,Hal ini juga dapat digunakan untuk membuat entri saham membuka dan memperbaiki nilai saham.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +87,Notes:,Catatan:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +88,Item Code and Warehouse should already exist.,Item Code dan Gudang harus sudah ada.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +89,You can update either Quantity or Valuation Rate or both.,Anda dapat memperbarui baik Quantity atau Tingkat Penilaian atau keduanya.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.js +90,"If no change in either Quantity or Valuation Rate, leave the cell blank.","Jika tidak ada perubahan baik Quantity atau Tingkat Penilaian, biarkan kosong sel."
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,Item: {0} not found in the system,Item: {0} tidak ditemukan dalam sistem
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +113,"Serialized Item {0} cannot be updated \
					using Stock Reconciliation",
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +118,"Item: {0} managed batch-wise, can not be reconciled using \
					Stock Reconciliation, instead use Stock Entry",
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +125,Row # ,Row # 
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +135,Stock Reconciliation file not uploaded,
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +157,Valuation Rate required for Item {0},Penilaian Tingkat diperlukan untuk Item {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +203,Please enter Cost Center,Masukkan Biaya Pusat
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +213,Please enter Expense Account,Masukkan Beban Akun
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +216,"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Perbedaan Akun harus rekening jenis 'Kewajiban', karena ini Stock Rekonsiliasi adalah sebuah entri Opening"
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +40,Wrong Template: Unable to find head row.,Template yang salah: Tidak dapat menemukan baris kepala.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +51,Row # {0}: ,Row # {0}: 
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +59,Sorry! We can only allow upto 100 rows for Stock Reconciliation.,
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,Duplicate entry,Gandakan entri
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +72,Warehouse not found in the system,Gudang tidak ditemukan dalam sistem
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77,Please specify either Quantity or Valuation Rate or both,Silakan tentukan baik Quantity atau Tingkat Penilaian atau keduanya
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +82,Negative Quantity is not allowed,Jumlah negatif tidak diperbolehkan
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,Negative Valuation Rate is not allowed,Tingkat Penilaian negatif tidak diperbolehkan
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,`Freeze Saham Lama Dari` harus lebih kecil dari% d hari.
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +101,New UOM must NOT be of type Whole Number,New UOM TIDAK harus dari jenis Whole Number
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +104,Conversion factor cannot be in fractions,Faktor konversi tidak dapat di fraksi
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +15,Item is required,Item diperlukan
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +18,New Stock UOM is required,New Stock UOM diperlukan
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +21,New Stock UOM must be different from current stock UOM,New Stock UOM harus berbeda dari UOM saham saat ini
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +25,Conversion Factor is required,Faktor konversi diperlukan
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +29,Item is updated,Item diperbarui
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +36,Stock UOM updated for Item {0},
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +57,Stock balances updated,Saldo saham diperbarui
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +73,Stock Ledger entries balances updated,Bursa Ledger entri saldo diperbarui
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +82,Item valuation updated,Item penilaian diperbarui
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +104,Warehouse {0} does not exist,Gudang {0} tidak ada
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +107,Both Warehouse must belong to same Company,Kedua Gudang harus merupakan gudang dari Perusahaan yang sama
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +19,Please enter valid Email Id,Silahkan lakukan validasi Email Id
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +59,Account head {0} created,Kepala akun {0} telah dibuat
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +63,Warehouse {0}: Company is mandatory,Gudang {0}: Perusahaan wajib
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +72,Please enter parent account group for warehouse {0},
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0}: Parent account {1} does not bolong to the company {2},Gudang {0}: akun induk {1} tidak terkait kepada perusahaan {2}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +85,Warehouse {0} can not be deleted as quantity exists for Item {1},Gudang {0} tidak dapat dihapus sebagai kuantitas ada untuk Item {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +95,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Gudang tidak dapat dihapus sebagai entri stok buku ada untuk gudang ini.
apps/erpnext/erpnext/stock/get_item_details.py +103,No Item with Barcode {0},Ada Barang dengan Barcode {0}
apps/erpnext/erpnext/stock/get_item_details.py +107,No Item with Serial No {0},Tidak ada Barang dengan Serial No {0}
apps/erpnext/erpnext/stock/get_item_details.py +113,Please specify Company,Silakan tentukan Perusahaan
apps/erpnext/erpnext/stock/get_item_details.py +122,Item {0} must be a Service Item.,Item {0} harus Layanan Barang.
apps/erpnext/erpnext/stock/get_item_details.py +125,Item {0} must be a Sales Item,Item {0} harus Item Penjualan
apps/erpnext/erpnext/stock/get_item_details.py +130,Item {0} must be a Purchase Item,Item {0} harus Pembelian Barang
apps/erpnext/erpnext/stock/get_item_details.py +133,Item {0} must be a Sub-contracted Item,Item {0} harus Item Sub-kontrak
apps/erpnext/erpnext/stock/get_item_details.py +226,Price List {0} is disabled,Daftar Harga {0} dinonaktifkan
apps/erpnext/erpnext/stock/get_item_details.py +228,Price List not selected,Daftar Harga tidak dipilih
apps/erpnext/erpnext/stock/get_item_details.py +243,Price List Currency not selected,Daftar Harga Mata uang tidak dipilih
apps/erpnext/erpnext/stock/get_item_details.py +395,No default BOM exists for Item {0},Tidak ada standar BOM ada untuk Item {0}
apps/erpnext/erpnext/stock/page/stock_ledger/stock_ledger.js +47,Balance Qty,Jumlah Saldo
apps/erpnext/erpnext/stock/page/stock_ledger/stock_ledger.js +50,Balance Value,Nilai Saldo
apps/erpnext/erpnext/stock/page/stock_ledger/stock_ledger.js +7,Stock Ledger,Bursa Ledger
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +40,Actual Qty: Quantity available in the warehouse.,Jumlah Aktual: Kuantitas yang tersedia di gudang.
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +41,"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Rencana Qty: Kuantitas, yang, Orde Produksi telah dibangkitkan, tetapi tertunda akan diproduksi."
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +42,"Requested Qty: Quantity requested for purchase, but not ordered.","Diminta Qty: Jumlah yang diminta untuk pembelian, tetapi tidak memerintahkan."
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +43,"Ordered Qty: Quantity ordered for purchase, but not received.","Memerintahkan Qty: Jumlah memerintahkan untuk pembelian, tetapi tidak diterima."
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +44,"Reserved Qty: Quantity ordered for sale, but not delivered.","Reserved Qty: Jumlah memerintahkan untuk dijual, tapi tidak disampaikan."
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +67,Actual Qty,Jumlah Aktual
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +69,Planned Qty,Rencana Qty
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +7,Stock Level,Tingkat Stock
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +71,Requested Qty,Diminta Qty
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +73,Ordered Qty,Memerintahkan Qty
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +75,Reserved Qty,Reserved Qty
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +79,Re-Order Level,Re-Order Tingkat
apps/erpnext/erpnext/stock/page/stock_level/stock_level.js +81,Re-Order Qty,Re-Order Qty
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +33,Batch,Batch
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +33,Opening Qty,Membuka Qty
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +34,In Qty,Dalam Qty
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +34,Out Qty,Out Qty
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +41,'From Date' is required,'Dari Tanggal' diperlukan
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +46,'To Date' is required,'To Date' diperlukan
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Last Purchase Rate,Tingkat Pembelian Terakhir
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Valuation Rate,Tingkat Penilaian
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +17,'From Date' must be after 'To Date','Dari Tanggal' harus setelah 'To Date'
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40,Consumed,
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40,Lead Time Days,Memimpin Waktu Hari
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40,Minimum Inventory Level,
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Avg Daily Outgoing,
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Total Outgoing,
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Reorder Level,
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +91,From and To dates required,Dari dan Untuk tanggal yang Anda inginkan
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Rata-rata Usia
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Terlama
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Terbaru
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.js +48,Voucher #,Voucher #
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +29,Stock UOM,Stock UOM
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +30,Incoming Rate,Tingkat yang masuk
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +32,Serial #,
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +34,Reorder Qty,
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +35,Shortage Qty,
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Qty,Dikonsumsi Qty
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Qty,Disampaikan Qty
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Amount,Jumlah Total
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),
apps/erpnext/erpnext/stock/stock_ledger.py +323,Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Kesalahan Stock negatif ({6}) untuk Item {0} Gudang {1} di {2} {3} in {4} {5}
apps/erpnext/erpnext/stock/stock_ledger.py +371,"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.",
apps/erpnext/erpnext/stock/utils.py +154,Serial number {0} entered more than once,Serial number {0} masuk lebih dari sekali
apps/erpnext/erpnext/stock/utils.py +159,{0} valid serial nos for Item {1},{0} nos seri berlaku untuk Item {1}
apps/erpnext/erpnext/stock/utils.py +166,Warehouse {0} does not belong to company {1},Gudang {0} bukan milik perusahaan {1}
apps/erpnext/erpnext/stock/utils.py +81,Item {0} ignored since it is not a stock item,Item {0} diabaikan karena bukan barang stok
apps/erpnext/erpnext/support/doctype/customer_issue/customer_issue.js +17,Make Maintenance Visit,Membuat Maintenance Visit
apps/erpnext/erpnext/support/doctype/customer_issue/customer_issue.py +16,{0}: From {1},
apps/erpnext/erpnext/support/doctype/customer_issue/customer_issue.py +20,Customer is required,Pelanggan diwajibkan
apps/erpnext/erpnext/support/doctype/customer_issue/customer_issue.py +33,Cancel Material Visit {0} before cancelling this Customer Issue,Batalkan Kunjungan {0} sebelum membatalkan Keluhan Pelanggan
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +125,Please save the document before generating maintenance schedule,Harap menyimpan dokumen sebelum menghasilkan jadwal pemeliharaan
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +60,Row {0}:Start Date must be before End Date,Row {0}: Tanggal awal harus sebelum Tanggal Akhir
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +148,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}",
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +154,Please enter Maintaince Details first,Cukup masukkan Maintaince Detail pertama
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +158,Please select item code,Silahkan pilih kode barang
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +160,Please select Start Date and End Date for Item {0},Silakan pilih Tanggal Mulai dan Tanggal Akhir untuk Item {0}
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +162,Please mention no of visits required,Harap menyebutkan tidak ada kunjungan yang diperlukan
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +164,Please select Incharge Person's name,Silahkan pilih nama Incharge Orang
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +167,Start date should be less than end date for Item {0},Tanggal mulai harus kurang dari tanggal akhir untuk Item {0}
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +176,Maintenance Schedule {0} exists against {0},Jadwal pemeliharaan {0} ada terhadap {0}
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +198,Serial No {0} not found,
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +201,Serial No {0} is under warranty upto {1},Serial ada {0} masih dalam garansi upto {1}
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +204,Serial No {0} is under maintenance contract upto {1},Serial ada {0} berada di bawah kontrak pemeliharaan upto {1}
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +208,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}
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +222,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'
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +226,Please click on 'Generate Schedule',Silahkan klik 'Menghasilkan Jadwal'
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +237,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}
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +48,Please click on 'Generate Schedule' to get schedule,Silahkan klik 'Menghasilkan Jadwal' untuk mendapatkan jadwal
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +18,From Maintenance Schedule,Dari Pemeliharaan Jadwal
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +30,From Customer Issue,Dari Pelanggan Issue
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +12,To {0},
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +67,Cancel Material Visits {0} before cancelling this Maintenance Visit,Batal Kunjungan Material {0} sebelum membatalkan ini Maintenance Visit
apps/erpnext/erpnext/support/doctype/newsletter/newsletter.js +19,Send,Kirim
apps/erpnext/erpnext/support/doctype/newsletter/newsletter.py +112,Please save the Newsletter before sending,Harap menyimpan Newsletter sebelum dikirim
apps/erpnext/erpnext/support/doctype/newsletter/newsletter.py +24,Scheduled to send to {0},Dijadwalkan untuk mengirim ke {0}
apps/erpnext/erpnext/support/doctype/newsletter/newsletter.py +29,Newsletter has already been sent,Newsletter telah terkirim
apps/erpnext/erpnext/support/doctype/newsletter/newsletter.py +42,Scheduled to send to {0} recipients,Dijadwalkan untuk mengirim ke {0} penerima
apps/erpnext/erpnext/support/doctype/newsletter/newsletter_list.html +7,No,Nomor
apps/erpnext/erpnext/support/doctype/newsletter/newsletter_list.html +7,Yes,Ya
apps/erpnext/erpnext/support/doctype/newsletter/newsletter_list.html +8,Not Sent,
apps/erpnext/erpnext/support/doctype/newsletter/newsletter_list.html +8,Sent,Terkirim
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Dukungan Analtyics
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +31,Select Fiscal Year,
apps/erpnext/erpnext/templates/form_grid/item_grid.html +26,Reqd By Date,Reqd By Date
apps/erpnext/erpnext/templates/form_grid/item_grid.html +76,hidden,
apps/erpnext/erpnext/templates/form_grid/item_grid.html +81,Discount,
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +37,For Warehouse,Untuk Gudang
apps/erpnext/erpnext/templates/form_grid/stock_entry_grid.html +24,In Stock,
apps/erpnext/erpnext/templates/form_grid/stock_entry_grid.html +25,Not In Stock,
apps/erpnext/erpnext/templates/generators/item.html +27,No description given,Tidak diberikan deskripsi
apps/erpnext/erpnext/templates/generators/item.html +38,Add to Cart,Tambahkan ke Keranjang Belanja
apps/erpnext/erpnext/templates/generators/item.html +55,Specifications,Spesifikasi
apps/erpnext/erpnext/templates/includes/cart.js +265,Something went wrong!,
apps/erpnext/erpnext/templates/includes/cart.js +285,Price List not configured.,
apps/erpnext/erpnext/templates/includes/cart.js +287,You need to be logged in to view your cart.,
apps/erpnext/erpnext/templates/includes/cart.js +289,Something went wrong.,
apps/erpnext/erpnext/templates/includes/cart.js +59,Go ahead and add something to your cart.,
apps/erpnext/erpnext/templates/includes/cart.js +99,Hey! Go ahead and add an address,
apps/erpnext/erpnext/templates/includes/footer_extension.html +39,Please enter email address,Masukkan alamat email
apps/erpnext/erpnext/templates/includes/footer_extension.html +6,Your email address,Alamat email Anda
apps/erpnext/erpnext/templates/includes/footer_extension.html +9,Stay Updated,Tetap Diperbarui
apps/erpnext/erpnext/templates/pages/invoice.py +27,To Pay,
apps/erpnext/erpnext/templates/pages/order.py +25,Partially Billed,
apps/erpnext/erpnext/templates/pages/order.py +30,Partially Delivered,
apps/erpnext/erpnext/templates/pages/ticket.py +27,Please write something,
apps/erpnext/erpnext/templates/pages/ticket.py +31,You are not allowed to reply to this ticket.,
apps/erpnext/erpnext/templates/pages/tickets.py +34,Please write something in subject and message!,
apps/erpnext/erpnext/templates/pages/user.py +34,Name is required,Nama dibutuhkan
apps/erpnext/erpnext/templates/print_formats/includes/item_grid.html +10,Sr,Sr
apps/erpnext/erpnext/templates/utils.py +65,Not Allowed,Tidak Diizinkan
apps/erpnext/erpnext/utilities/__init__.py +24,Status must be one of {0},Status harus menjadi salah satu {0}
apps/erpnext/erpnext/utilities/doctype/address/address.py +21,Address Title is mandatory.,"Wajib masukan Judul Alamat.,"
apps/erpnext/erpnext/utilities/doctype/address/address.py +67,No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Tidak ada Alamat bawaan Template ditemukan. Harap membuat yang baru dari Pengaturan> Percetakan dan Branding> Template Alamat.
apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +15,Setting this Address Template as default as there is no other default,Mengatur Template Alamat ini sebagai default karena tidak ada standar lainnya
apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +24,Default Address Template cannot be deleted,Template Default Address tidak bisa dihapus
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.js +22,Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,Upload file csv dengan dua kolom:. Nama lama dan nama baru. Max 500 baris.
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +34,Please select a valid csv file with data,Silakan pilih file csv dengan data yang valid
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +38,Maximum {0} rows allowed,Maksimum {0} baris diperbolehkan
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +46,Successful: ,Successful: 
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +49,Ignored: ,Ignored: 
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +52,Failed: ,Failed: 
apps/erpnext/erpnext/utilities/transaction_base.py +114,Quantity cannot be a fraction in row {0},Kuantitas tidak bisa menjadi fraksi di baris {0}
apps/erpnext/erpnext/utilities/transaction_base.py +74,Duplicate row {0} with same {1},Baris duplikat {0} dengan sama {1}
sites/assets/js/erpnext.min.js +19,Edit,Ubah
sites/assets/js/erpnext.min.js +19,No address added yet.,
sites/assets/js/erpnext.min.js +19,Primary,Utama
sites/assets/js/erpnext.min.js +19,Shipping,Pengiriman
sites/assets/js/erpnext.min.js +2,""" does not exists","""Tidak ada"
sites/assets/js/erpnext.min.js +2,"Grid ""","Grid """
sites/assets/js/erpnext.min.js +20,Email Id,Email Id
sites/assets/js/erpnext.min.js +20,No contacts added yet.,
sites/assets/js/erpnext.min.js +20,Phone,Telepon
sites/assets/js/erpnext.min.js +5,Add,Tambahkan
sites/assets/js/erpnext.min.js +5,Add Serial No,Tambahkan Nomor Serial
sites/assets/js/erpnext.min.js +5,Serial No,Serial ada
sites/assets/js/erpnext.min.js +6,Please specify a,Silakan tentukan
