DocType: Employee,Salary Mode,Mode Gaji
apps/erpnext/erpnext/hub_node/page/hub/hub.js +67,Register,Daftar
DocType: Patient,Divorced,Bercerai
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Izinkan Stok Barang yang sama untuk ditambahkan beberapa kali dalam suatu transaksi
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Batal Bahan Kunjungan {0} sebelum membatalkan Garansi Klaim ini
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Produk Pelanggan
DocType: Purchase Receipt,Subscription Detail,Detail Langganan
DocType: Supplier Scorecard,Notify Supplier,Beritahu Pemasok
DocType: Item,Customer Items,Produk Pelanggan
DocType: Project,Costing and Billing,Biaya dan Penagihan
apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Akun {0}: akun Induk {1} tidak dapat berupa buku besar
DocType: Item,Publish Item to hub.erpnext.com,Publikasikan Item untuk hub.erpnext.com
apps/erpnext/erpnext/config/setup.py +88,Email Notifications,Notifikasi Email
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,Evaluasi
DocType: Item,Default Unit of Measure,Standar Satuan Ukur
DocType: SMS Center,All Sales Partner Contact,Semua Kontak Mitra Penjualan
DocType: Employee,Leave Approvers,Approval Cuti
DocType: Sales Partner,Dealer,Dealer (Pelaku)
DocType: Consultation,Investigations,Investigasi
DocType: Restaurant Order Entry,Click Enter To Add,Klik Enter To Add
DocType: Employee,Rented,Sewaan
DocType: Purchase Order,PO-,po
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Berhenti Order Produksi tidak dapat dibatalkan, unstop terlebih dahulu untuk membatalkan"
DocType: Vehicle Service,Mileage,Jarak tempuh
apps/erpnext/erpnext/assets/doctype/asset/asset.js +240,Do you really want to scrap this asset?,Apakah Anda benar-benar ingin membatalkan aset ini?
DocType: Drug Prescription,Update Schedule,Perbarui Jadwal
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Pilih Default Pemasok
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Mata Uang diperlukan untuk Daftar Harga {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Akan dihitung dalam transaksi.
DocType: Purchase Order,Customer Contact,Kontak Pelanggan
DocType: Patient Appointment,Check availability,Cek ketersediaan
DocType: Job Applicant,Job Applicant,Pemohon Kerja
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Hal ini didasarkan pada transaksi terhadap Pemasok ini. Lihat timeline di bawah untuk rincian
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Hukum
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Jenis pajak aktual tidak dapat dimasukkan dalam tarif di baris {0}
DocType: Bank Guarantee,Customer,Pelanggan
DocType: Purchase Receipt Item,Required By,Diperlukan Oleh
DocType: Delivery Note,Return Against Delivery Note,Retur Terhadap Nota Pengiriman
DocType: Purchase Order,% Billed,Ditagih %
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Kurs harus sama dengan {0} {1} ({2})
DocType: Sales Invoice,Customer Name,Nama Pelanggan
DocType: Vehicle,Natural Gas,Gas alam
apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Rekening bank tidak dapat namakan sebagai {0}
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Kepala (atau kelompok) terhadap yang Entri Akuntansi dibuat dan saldo dipertahankan.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Posisi untuk {0} tidak bisa kurang dari nol ({1})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Tidak ada slip Saldo yang diajukan untuk diproses.
DocType: Manufacturing Settings,Default 10 mins,Standar 10 menit
DocType: Leave Type,Leave Type Name,Nama Tipe Cuti
apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Tampilkan terbuka
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Hal ini diperlukan untuk mengambil tindakan ini hari ini sendiri untuk berulang di atas
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Nomor Seri Berhasil Diperbarui
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Periksa
DocType: Pricing Rule,Apply On,Terapkan Pada
DocType: Item Price,Multiple Item prices.,Multiple Item harga.
,Purchase Order Items To Be Received,Order Pembelian Stok Barang Akan Diterima
DocType: SMS Center,All Supplier Contact,Kontak semua Supplier
DocType: Support Settings,Support Settings,Pengaturan dukungan
apps/erpnext/erpnext/projects/doctype/project/project.py +72,Expected End Date can not be less than Expected Start Date,Diharapkan Tanggal Berakhir tidak bisa kurang dari yang diharapkan Tanggal Mulai
apps/erpnext/erpnext/utilities/transaction_base.py +115,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Tingkat harus sama dengan {1}: {2} ({3} / {4})
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,Aplikasi Cuti Baru
,Batch Item Expiry Status,Status Kadaluarsa Persediaan Batch
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Bank Draft
DocType: Membership,membership validaty section,bagian keanggotaan validitas
DocType: Mode of Payment Account,Mode of Payment Account,Mode Akun Pembayaran Rekening
DocType: Consultation,Consultation,Konsultasi
DocType: Accounts Settings,Show Payment Schedule in Print,Tampilkan Jadwal Pembayaran di Cetak
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Penjualan dan Pengembalian
apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Tampilkan Varian
DocType: Academic Term,Academic Term,Jangka Akademis
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Bahan
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Membuat website
DocType: Opening Invoice Creation Tool Item,Quantity,Kuantitas
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +544,Accounts table cannot be blank.,Tabel account tidak boleh kosong.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Kredit (Kewajiban)
DocType: Employee Education,Year of Passing,Tahun Berjalan
DocType: Item,Country of Origin,Negara Asal
DocType: Soil Texture,Soil Texture Criteria,Kriteria Tekstur Tanah
apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,Dalam Persediaan
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Rincian Kontak Utama
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,terbuka Isu
DocType: Production Plan Item,Production Plan Item,Rencana Produksi Stok Barang
apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Pengguna {0} sudah ditugaskan untuk Karyawan {1}
DocType: Lab Test Groups,Add new line,Tambahkan baris baru
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Kesehatan
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Keterlambatan pembayaran (Hari)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Rincian Syarat Pembayaran
DocType: Lab Prescription,Lab Prescription,Resep Lab
apps/erpnext/erpnext/hub_node/page/hub/hub.js +185,Sort by Price,Urutkan berdasarkan harga
,Delay Days,Tunda hari
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Beban layanan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +886,Serial Number: {0} is already referenced in Sales Invoice: {1},Nomor Seri: {0} sudah dirujuk dalam Faktur Penjualan: {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +878,Invoice,Faktur
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +109,Make Retention Stock Entry,Buat Entri Stok Retensi
DocType: Purchase Invoice Item,Item Weight Details,Rincian Berat Item
DocType: Asset Maintenance Log,Periodicity,Periode
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Tahun fiskal {0} diperlukan
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Jarak minimum antara deretan tanaman untuk pertumbuhan optimum
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Pertahanan
DocType: Salary Component,Abbr,Singkatan
DocType: Appraisal Goal,Score (0-5),Skor (0-5)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +223,Row {0}: {1} {2} does not match with {3},Baris {0}: {1} {2} tidak cocok dengan {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77,Row # {0}:,Row # {0}:
DocType: Timesheet,Total Costing Amount,Jumlah Total Biaya
DocType: Delivery Note,Vehicle No,Nomor Kendaraan
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +160,Please select Price List,Silakan pilih Daftar Harga
DocType: Accounts Settings,Currency Exchange Settings,Pengaturan Pertukaran Mata Uang
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Dokumen Pembayaran diperlukan untuk menyelesaikan trasaction yang
DocType: Production Order Operation,Work In Progress,Pekerjaan dalam proses
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Silakan pilih tanggal
DocType: Employee,Holiday List,Daftar Hari Libur
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Akuntan
DocType: Hub Settings,Selling Price List,Daftar Harga Jual
DocType: Patient,Tobacco Current Use,Penggunaan Saat Ini Tembakau
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56,Selling Rate,Tingkat penjualan
DocType: Cost Center,Stock User,Pengguna Persediaan
DocType: Soil Analysis,(Ca+Mg)/K,(Ca+Mg)/K
DocType: Company,Phone No,No Telepon yang
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +237,New {0}: #{1},Baru {0}: # {1}
DocType: Delivery Trip,Initial Email Notification Sent,Pemberitahuan email awal terkirim
,Sales Partners Commission,Komisi Mitra Penjualan
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Purchase Invoice,Rounding Adjustment,Penyesuaian Pembulatan
apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Singkatan tidak boleh melebihi 5 karakter
DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Jadwal Waktu Slot Dokter
DocType: Payment Request,Payment Request,Permintaan pembayaran
DocType: Asset,Value After Depreciation,Nilai Setelah Penyusutan
DocType: Student,O+,O +
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,terkait
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,tanggal kehadiran tidak bisa kurang dari tanggal bergabung karyawan
DocType: Grading Scale,Grading Scale Name,Skala Grading Nama
DocType: Subscription,Repeat on Day,Ulangi pada hari
apps/erpnext/erpnext/accounts/doctype/account/account.js +41,This is a root account and cannot be edited.,Ini adalah account root dan tidak dapat diedit.
DocType: Sales Invoice,Company Address,Alamat perusahaan
DocType: BOM,Operations,Operasi
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}
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Melampirkan file .csv dengan dua kolom, satu untuk nama lama dan satu untuk nama baru"
apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} tidak dalam Tahun Anggaran aktif.
DocType: Packed Item,Parent Detail docname,Induk Detil docname
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Referensi: {0}, Kode Item: {1} dan Pelanggan: {2}"
apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,Kg
apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Lowongan untuk Pekerjaan.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +110,BOM is not specified for subcontracting item {0} at row {1},BOM belum ditentukan untuk subkontrak barang {0} pada baris {1}
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Hasil terkirim
DocType: Item Attribute,Increment,Kenaikan
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +61,Timespan,Rentang waktu
apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Pilih Gudang ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Periklanan (Promosi)
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Perusahaan yang sama dimasukkan lebih dari sekali
DocType: Patient,Married,Menikah
apps/erpnext/erpnext/accounts/party.py +44,Not permitted for {0},Tidak diizinkan untuk {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Mendapatkan Stok Barang-Stok Barang dari
DocType: Price List,Price Not UOM Dependant,Harga UOM Tidak Tergantung
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +454,Stock cannot be updated against Delivery Note {0},Persediaan tidak dapat diperbarui terhadap Nota Pengiriman {0}
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produk {0}
apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Tidak ada item yang terdaftar
DocType: Asset Repair,Error Description,Deskripsi kesalahan
DocType: Payment Reconciliation,Reconcile,Rekonsiliasi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Toko Kelontongan
DocType: Quality Inspection Reading,Reading 1,Membaca 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Dana pensiun
apps/erpnext/erpnext/assets/doctype/asset/asset.py +91,Next Depreciation Date cannot be before Purchase Date,Berikutnya Penyusutan Tanggal tidak boleh sebelum Tanggal Pembelian
DocType: Crop,Perennial,Abadi
DocType: Consultation,Consultation Date,Tanggal Konsultasi
apps/erpnext/erpnext/hub_node/page/hub/hub.js +131,Product listing and discovery for ERPNext users,Daftar produk dan penemuan untuk pengguna ERPNext
DocType: SMS Center,All Sales Person,Semua Salesmen
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Distribusi Bulanan ** membantu Anda mendistribusikan Anggaran / Target di antara bulan-bulan jika bisnis Anda memiliki musim.
apps/erpnext/erpnext/accounts/page/pos/pos.js +1743,Not items found,Tidak item yang ditemukan
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Struktur Gaji Hilang
DocType: Lead,Person Name,Nama orang
DocType: Sales Invoice Item,Sales Invoice Item,Faktur Penjualan Stok Barang
DocType: Account,Credit,Kredit
DocType: POS Profile,Write Off Cost Center,Write Off Biaya Pusat
apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",misalnya &quot;Sekolah Dasar&quot; atau &quot;Universitas&quot;
apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Laporan Persediaan
DocType: Warehouse,Warehouse Detail,Detail Gudang
apps/erpnext/erpnext/selling/doctype/customer/customer.py +193,Credit limit has been crossed for customer {0} {1}/{2},Batas kredit telah terlampaui untuk Pelanggan {0} {1}/{2}
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Jangka Tanggal Akhir tidak bisa lebih lambat dari Akhir Tahun Tanggal Tahun Akademik yang istilah terkait (Tahun Akademik {}). Perbaiki tanggal dan coba lagi.
apps/erpnext/erpnext/stock/doctype/item/item.py +258,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Aset Tetap"" tidak dapat tidak dicentang, karena ada data Asset terhadap barang"
DocType: Delivery Trip,Departure Time,Waktu keberangkatan
DocType: Vehicle Service,Brake Oil,Minyak Rem
DocType: Tax Rule,Tax Type,Jenis pajak
apps/erpnext/erpnext/controllers/taxes_and_totals.py +568,Taxable Amount,Jumlah Kena Pajak
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Anda tidak diizinkan menambah atau memperbarui entri sebelum {0}
DocType: BOM,Item Image (if not slideshow),Gambar Stok Barang (jika tidak slideshow)
DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Tarif per Jam / 60) * Masa Beroperasi Sebenarnya
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Baris # {0}: Jenis Dokumen Referensi harus menjadi salah satu Klaim Biaya atau Entri Jurnal
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +964,Select BOM,Pilih BOM
DocType: SMS Log,SMS Log,SMS Log
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Biaya Produk Terkirim
apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Mengelola jumlah uang muka yang diberikan kepada Karyawan
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Liburan di {0} bukan antara Dari Tanggal dan To Date
DocType: Student Log,Student Log,Mahasiswa Log
DocType: Quality Inspection,Get Specification Details,Dapatkan Spesifikasi Detail
apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Template dari klasemen pemasok.
DocType: Lead,Interested,Tertarik
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +191,Opening,Pembukaan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +30,From {0} to {1},Dari {0} ke {1}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Gagal menyetorkan pajak
DocType: Item,Copy From Item Group,Salin Dari Grup Stok Barang
DocType: Delivery Trip,Delivery Notification,Pemberitahuan pengiriman
DocType: Journal Entry,Opening Entry,Entri Pembukaan
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Akun Pembayaran Saja
DocType: Employee Loan,Repay Over Number of Periods,Membayar Lebih dari Jumlah Periode
DocType: Stock Entry,Additional Costs,Biaya-biaya tambahan
apps/erpnext/erpnext/accounts/doctype/account/account.py +138,Account with existing transaction can not be converted to group.,Akun dengan transaksi yang ada tidak dapat dikonversi ke grup.
DocType: Lead,Product Enquiry,Produk Enquiry
DocType: Education Settings,Validate Batch for Students in Student Group,Validasi Batch untuk Siswa di Kelompok Pelajar
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Tidak ada cuti record yang ditemukan untuk karyawan {0} untuk {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Silahkan masukkan perusahaan terlebih dahulu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Company first,Silakan pilih Perusahaan terlebih dahulu
DocType: Employee Education,Under Graduate,Sarjana
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Sasaran On
DocType: BOM,Total Cost,Total Biaya
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Journal Entry Account,Employee Loan,Pinjaman karyawan
DocType: Fee Schedule,Send Payment Request Email,Kirim Permintaan Pembayaran Email
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +259,Item {0} does not exist in the system or has expired,Item {0} tidak ada dalam sistem atau telah berakhir
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Real Estate
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Laporan Rekening
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Farmasi
DocType: Purchase Invoice Item,Is Fixed Asset,Apakah Aset Tetap
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +256,"Available qty is {0}, you need {1}","Tersedia qty adalah {0}, Anda perlu {1}"
DocType: Expense Claim Detail,Claim Amount,Nilai Klaim
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,kelompok pelanggan duplikat ditemukan di tabel kelompok cutomer
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Supplier Type / Supplier
DocType: Naming Series,Prefix,Awalan
apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Lokasi acara
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Consumable
DocType: Student,B-,B-
DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Tarik Bahan Permintaan jenis Industri berdasarkan kriteria di atas
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +100,Successfully unregistered.,Berhasil tidak terdaftar
DocType: Assessment Result,Grade,Kelas
DocType: Restaurant Table,No of Seats,Tidak ada tempat duduk
DocType: Subscription,"To add dynamic subject, use jinja tags like

<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Untuk menambahkan subjek dinamis, gunakan tag jinja seperti <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
DocType: Sales Invoice Item,Delivered By Supplier,Terkirim Oleh Supplier
DocType: Asset Maintenance Task,Asset Maintenance Task,Tugas Pemeliharaan Aset
DocType: SMS Center,All Contact,Semua Kontak
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +952,Production Order already created for all items with BOM,Pesanan produksi sudah dibuat untuk semua item dengan BOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +230,Annual Salary,Gaji Tahunan
DocType: Daily Work Summary,Daily Work Summary,Ringkasan Pekerjaan sehari-hari
DocType: Period Closing Voucher,Closing Fiscal Year,Penutup Tahun Anggaran
apps/erpnext/erpnext/accounts/party.py +380,{0} {1} is frozen,{0} {1} dibekukan
apps/erpnext/erpnext/setup/doctype/company/company.py +136,Please select Existing Company for creating Chart of Accounts,Silakan pilih Perusahaan yang ada untuk menciptakan Chart of Account
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Beban Persediaan
apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Pilih Target Warehouse
apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Silahkan masukkan Kontak Email Utama
DocType: Journal Entry,Contra Entry,Contra Entri
DocType: Journal Entry Account,Credit in Company Currency,Kredit di Perusahaan Mata
DocType: Lab Test UOM,Lab Test UOM,Uji Lab UOM
DocType: Delivery Note,Installation Status,Status Instalasi
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Apakah Anda ingin memperbarui kehadiran? <br> Hadir: {0} \ <br> Absen: {1}
apps/erpnext/erpnext/controllers/buying_controller.py +344,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Jumlah Diterima + Ditolak harus sama dengan jumlah yang diterima untuk Item {0}
DocType: Request for Quotation,RFQ-,RFQ-
DocType: Item,Supply Raw Materials for Purchase,Bahan pasokan baku untuk Pembelian
DocType: Agriculture Analysis Criteria,Fertilizer,Pupuk
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +150,At least one mode of payment is required for POS invoice.,Setidaknya satu cara pembayaran diperlukan untuk POS faktur.
DocType: Products Settings,Show Products as a List,Tampilkan Produk sebagai sebuah Daftar
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +512,Item {0} is not active or end of life has been reached,Item {0} tidak aktif atau akhir hidup telah tercapai
DocType: Student Admission Program,Minimum Age,Usia Minimum
apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Contoh: Matematika Dasar
apps/erpnext/erpnext/controllers/accounts_controller.py +793,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Untuk mencakup pajak berturut-turut {0} di tingkat Stok Barang, pajak dalam baris {1} juga harus disertakan"
apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Pengaturan untuk modul HR
DocType: SMS Center,SMS Center,SMS Center
DocType: Sales Invoice,Change Amount,perubahan Jumlah
DocType: BOM Update Tool,New BOM,BOM Baru
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Hanya tampilkan POS
DocType: Driver,Driving License Categories,Kategori Lisensi Mengemudi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Harap masukkan Tanggal Pengiriman
DocType: Depreciation Schedule,Make Depreciation Entry,Membuat Penyusutan Masuk
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Permintaan Type
apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,membuat Karyawan
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Penyiaran
apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Modus setup POS (Online / Offline)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,Eksekusi
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Rincian operasi yang dilakukan.
DocType: Asset Maintenance Log,Maintenance Status,Status pemeliharaan
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Rincian Keanggotaan
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Pemasok diperlukan untuk akun Hutang {2}
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Item dan Harga
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Jumlah jam: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Dari tanggal harus dalam Tahun Anggaran. Dengan asumsi Dari Tanggal = {0}
DocType: Drug Prescription,Interval,Selang
DocType: Grant Application,Individual,Individu
DocType: Academic Term,Academics User,Pengguna Akademis
DocType: Cheque Print Template,Amount In Figure,Jumlah Dalam Gambar
DocType: Employee Loan Application,Loan Info,Info kredit
apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Rencana kunjungan pemeliharaan.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Periode Scorecard Supplier
DocType: POS Profile,Customer Groups,Grup Pelanggan
apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Laporan keuangan
DocType: Guardian,Students,siswa
apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Aturan untuk menerapkan harga dan diskon.
DocType: Physician Schedule,Time Slots,Slot waktu
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Harga List harus berlaku untuk Membeli atau Jual
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Tanggal instalasi tidak bisa sebelum tanggal pengiriman untuk Item {0}
DocType: Pricing Rule,Discount on Price List Rate (%),Diskon Harga Daftar Rate (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Item Template
apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biokimia
DocType: Offer Letter,Select Terms and Conditions,Pilih Syarat dan Ketentuan
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,out Nilai
DocType: Production Planning Tool,Sales Orders,Order Penjualan
DocType: Purchase Taxes and Charges,Valuation,Valuation
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +380,Set as Default,Set sebagai Default
,Purchase Order Trends,Trend Order Pembelian
apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Pergi ke pelanggan
apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Permintaan untuk kutipan dapat diakses dengan mengklik link berikut
apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Alokasi cuti untuk tahun berjalan.
DocType: SG Creation Tool Course,SG Creation Tool Course,SG Penciptaan Alat Course
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +258,Insufficient Stock,Persediaan tidak cukup
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Nonaktifkan Perencanaan Kapasitas dan Waktu Pelacakan
DocType: Email Digest,New Sales Orders,Penjualan New Orders
DocType: Bank Guarantee,Bank Account,Rekening Bank
DocType: Leave Type,Allow Negative Balance,Izinkan Saldo Negatif
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Anda tidak bisa menghapus Jenis Proyek 'External'
DocType: Employee,Create User,Buat pengguna
DocType: Selling Settings,Default Territory,Wilayah Standar
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televisi
DocType: Production Order Operation,Updated via 'Time Log',Diperbarui melalui 'Log Waktu'
apps/erpnext/erpnext/controllers/taxes_and_totals.py +428,Advance amount cannot be greater than {0} {1},Jumlah muka tidak dapat lebih besar dari {0} {1}
DocType: Naming Series,Series List for this Transaction,Daftar Series Transaksi ini
DocType: Company,Enable Perpetual Inventory,Aktifkan Inventaris Abadi
DocType: Company,Default Payroll Payable Account,Default Payroll Hutang Akun
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Perbarui Email Kelompok
DocType: Sales Invoice,Is Opening Entry,Entri Pembuka?
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Jika tidak dicentang, item tersebut tidak akan muncul dalam Sales Invoice, namun dapat digunakan dalam pembuatan uji kelompok."
DocType: Customer Group,Mention if non-standard receivable account applicable,Sebutkan jika akun non-standar piutang yang berlaku
DocType: Course Schedule,Instructor Name,instruktur Nama
DocType: Supplier Scorecard,Criteria Setup,Setup kriteria
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,For Warehouse is required before Submit,Untuk Gudang diperlukan sebelum Submit
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Diterima pada
DocType: Sales Partner,Reseller,Reseller
DocType: Codification Table,Medical Code,Kode medis
DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Jika dicentang, akan mencakup barang non-persediaan di Permintaan Material."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Pilih Perusahaan
DocType: Delivery Note Item,Against Sales Invoice Item,Terhadap Barang di Faktur Penjualan
DocType: Agriculture Analysis Criteria,Linked Doctype,Linked Doctype
,Production Orders in Progress,Order produksi dalam Proses
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Kas Bersih dari Pendanaan
apps/erpnext/erpnext/accounts/page/pos/pos.js +2333,"LocalStorage is full , did not save","LocalStorage penuh, tidak menyimpan"
DocType: Lead,Address & Contact,Alamat & Kontak
DocType: Leave Allocation,Add unused leaves from previous allocations,Tambahkan 'cuti tak terpakai' dari alokasi sebelumnya
DocType: Sales Partner,Partner website,situs mitra
DocType: Restaurant Order Entry,Add Item,Tambahkan Barang
DocType: Lab Test,Custom Result,Hasil Kustom
DocType: Delivery Stop,Contact Name,Nama Kontak
DocType: Course Assessment Criteria,Course Assessment Criteria,Kriteria Penilaian saja
DocType: POS Customer Group,POS Customer Group,POS Pelanggan Grup
DocType: Land Unit,Land Unit describing various land assets,Unit Tanah yang menggambarkan berbagai aset pertanahan
DocType: Cheque Print Template,Line spacing for amount in words,spasi untuk jumlah kata
DocType: Vehicle,Additional Details,Rincian Tambahan
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Rencana Penilaian:
apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Tidak diberikan deskripsi
apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Form Permintaan pembelian.
DocType: Lab Test,Submitted Date,Tanggal dikirim
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Hal ini didasarkan pada Lembar Waktu diciptakan terhadap proyek ini
DocType: Payment Term,Credit Months,Bulan kredit
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Pay bersih yang belum bisa kurang dari 0
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Untuk berhenti mengirim pemberitahuan kesalahan berulang dari sistem, kami telah memeriksa kolom Nonaktif dalam langganan"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Hanya dipilih Cuti Approver dapat mengirimkan Aplikasi Cuti ini
apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,Menghilangkan Tanggal harus lebih besar dari Tanggal Bergabung
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Leaves per Year,cuti per Tahun
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +128,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,Baris {0}: Silakan periksa 'Apakah Muka' terhadap Rekening {1} jika ini adalah sebuah entri muka.
apps/erpnext/erpnext/stock/utils.py +216,Warehouse {0} does not belong to company {1},Gudang {0} bukan milik perusahaan {1}
DocType: Email Digest,Profit & Loss,Rugi laba
apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Liter
DocType: Task,Total Costing Amount (via Time Sheet),Total Costing Jumlah (via Waktu Lembar)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Tolong atur Siswa di Kelompok Siswa
DocType: Item Website Specification,Item Website Specification,Item Situs Spesifikasi
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +509,Leave Blocked,Cuti Diblokir
apps/erpnext/erpnext/stock/doctype/item/item.py +709,Item {0} has reached its end of life on {1},Item {0} telah mencapai akhir hidupnya pada {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +99,Bank Entries,Entri Bank
DocType: Crop,Annual,Tahunan
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Barang Rekonsiliasi Persediaan
DocType: Stock Entry,Sales Invoice No,Nomor Faktur Penjualan
DocType: Material Request Item,Min Order Qty,Min Order Qty
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Kursus Grup Pelajar Penciptaan Alat
DocType: Lead,Do Not Contact,Jangan Hubungi
apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,Orang-orang yang mengajar di organisasi Anda
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Software Developer
DocType: Item,Minimum Order Qty,Minimum Order Qty
DocType: Pricing Rule,Supplier Type,Supplier Type
DocType: Course Scheduling Tool,Course Start Date,Tentu saja Tanggal Mulai
,Student Batch-Wise Attendance,Mahasiswa Batch-Wise Kehadiran
DocType: POS Profile,Allow user to edit Rate,Memungkinkan pengguna untuk mengedit Tingkat
DocType: Item,Publish in Hub,Publikasikan di Hub
DocType: Student Admission,Student Admission,Mahasiswa Pendaftaran
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +729,Item {0} is cancelled,Item {0} dibatalkan
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +952,Material Request,Permintaan Material
DocType: Bank Reconciliation,Update Clearance Date,Perbarui Tanggal Kliring
DocType: Item,Purchase Details,Rincian pembelian
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +387,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Item {0} tidak ditemukan dalam &#39;Bahan Baku Disediakan&#39; tabel dalam Purchase Order {1}
DocType: Salary Slip,Total Principal Amount,Jumlah Pokok Jumlah
DocType: Student Guardian,Relation,Hubungan
DocType: Student Guardian,Mother,Ibu
DocType: Restaurant Reservation,Reservation End Time,Reservasi Akhir Waktu
DocType: Crop,Biennial,Dua tahunan
apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Pesanan terkonfirmasi dari Pelanggan.
DocType: Purchase Receipt Item,Rejected Quantity,Kuantitas Ditolak
apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Permintaan pembayaran {0} dibuat
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Pesanan Terbuka
apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Sensitivitas rendah
DocType: Notification Control,Notification Control,Pemberitahuan Kontrol
apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Harap konfirmasi setelah Anda menyelesaikan pelatihan Anda
DocType: Lead,Suggestions,Saran
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Menetapkan anggaran Group-bijaksana Stok Barang di Wilayah ini. Anda juga bisa memasukkan musiman dengan menetapkan Distribusi.
DocType: Payment Term,Payment Term Name,Nama Istilah Pembayaran
DocType: Healthcare Settings,Create documents for sample collection,Buat dokumen untuk koleksi sampel
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +274,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Pembayaran terhadap {0} {1} tidak dapat lebih besar dari Posisi Jumlah {2}
DocType: Supplier,Address HTML,Alamat HTML
DocType: Lead,Mobile No.,Nomor Ponsel
DocType: Maintenance Schedule,Generate Schedule,Hasilkan Jadwal
DocType: Purchase Invoice Item,Expense Head,Akun Kepala Biaya
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +163,Please select Charge Type first,Silakan pilih Mengisi Tipe terlebih dahulu
DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Anda dapat menentukan semua tugas yang perlu dilakukan untuk tanaman ini di sini. Bidang hari digunakan untuk menyebutkan hari dimana tugas tersebut perlu dilakukan, 1 menjadi hari pertama, dll."
DocType: Student Group Student,Student Group Student,Mahasiswa Grup Pelajar
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Terbaru
DocType: Asset Maintenance Task,2 Yearly,2 Tahunan
DocType: Education Settings,Education Settings,Pengaturan Pendidikan
DocType: Vehicle Service,Inspection,Inspeksi
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
DocType: Email Digest,New Quotations,Kutipan Baru
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Surel slip gaji ke karyawan berdasarkan surel utama yang dipilih dalam Karyawan
DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,The Approver Cuti terlebih dahulu dalam daftar akan ditetapkan sebagai default Cuti Approver
DocType: Tax Rule,Shipping County,Pengiriman County
apps/erpnext/erpnext/config/desktop.py +167,Learn,Belajar
DocType: Asset,Next Depreciation Date,Berikutnya Penyusutan Tanggal
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Biaya Aktivitas Per Karyawan
DocType: Accounts Settings,Settings for Accounts,Pengaturan Akun
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673,Supplier Invoice No exists in Purchase Invoice {0},Pemasok Faktur ada ada di Purchase Invoice {0}
apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Pengelolaan Tingkat Salesman
DocType: Job Applicant,Cover Letter,Sampul surat
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Penghapusan Cek dan Deposito yang Jatuh Tempo
DocType: Item,Synced With Hub,Disinkronkan Dengan Hub
DocType: Driver,Fleet Manager,armada Manajer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} tidak bisa menjadi negatif untuk item {2}
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Kata Sandi Salah
DocType: Item,Variant Of,Varian Of
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',Selesai Qty tidak dapat lebih besar dari 'Jumlah untuk Produksi'
DocType: Period Closing Voucher,Closing Account Head,Penutupan Akun Kepala
DocType: Employee,External Work History,Pengalaman Kerja Diluar
DocType: Physician,Time per Appointment,Waktu per Penunjukan
apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Referensi Kesalahan melingkar
DocType: Appointment Type,Is Inpatient,Apakah rawat inap
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Nama Guardian1
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,Dalam Kata-kata (Ekspor) akan terlihat sekali Anda menyimpan Delivery Note.
DocType: Cheque Print Template,Distance from left edge,Jarak dari tepi kiri
apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} unit [{1}] (#Formulir/Barang/{1}) ditemukan di [{2}] (#Formulir/Gudang/{2})
DocType: Lead,Industry,Industri
DocType: Employee,Job Profile,Profil Pekerjaan
DocType: BOM Item,Rate & Amount,Tarif &amp; Jumlah
apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Hal ini didasarkan pada transaksi terhadap Perusahaan ini. Lihat garis waktu di bawah untuk rinciannya
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Beritahu melalui Surel pada pembuatan Permintaan Material otomatis
apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Tahan
apps/erpnext/erpnext/config/desktop.py +309,Consultationt,Konsultasi
DocType: Journal Entry,Multi Currency,Multi Mata Uang
DocType: Opening Invoice Creation Tool,Invoice Type,Tipe Faktur
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +933,Delivery Note,Nota Pengiriman
DocType: Consultation,Encounter Impression,Tayangan Pertemuan
apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Persiapan Pajak
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Biaya Asset Terjual
DocType: Volunteer,Morning,Pagi
apps/erpnext/erpnext/accounts/utils.py +350,Payment Entry has been modified after you pulled it. Please pull it again.,Entri pembayaran telah dimodifikasi setelah Anda menariknya. Silakan menariknya lagi.
DocType: Program Enrollment Tool,New Student Batch,Batch Siswa Baru
apps/erpnext/erpnext/stock/doctype/item/item.py +464,{0} entered twice in Item Tax,{0} dimasukan dua kali dalam Pajak Barang
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Ringkasan untuk minggu ini dan kegiatan yang tertunda
DocType: Student Applicant,Admitted,Diterima
DocType: Workstation,Rent Cost,Biaya Sewa
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Jumlah Setelah Penyusutan
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Mendatang Kalender Acara
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Atribut varian
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,Silakan pilih bulan dan tahun
DocType: Employee,Company Email,Email Perusahaan
DocType: GL Entry,Debit Amount in Account Currency,Jumlah Debit di Akun Mata Uang
DocType: Supplier Scorecard,Scoring Standings,Klasemen Skor
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Nilai pesanan
apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Transaksi Bank / Cash terhadap partai atau untuk internal transfer
DocType: Shipping Rule,Valid for Countries,Berlaku untuk Negara
apps/erpnext/erpnext/stock/doctype/item/item.js +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,Stok Barang ini adalah Template dan tidak dapat digunakan dalam transaksi. Item atribut akan disalin ke dalam varian kecuali 'Tidak ada Copy' diatur
DocType: Grant Application,Grant Application,Permohonan Hibah
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Total Order Diperhitungkan
apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Penunjukan Karyawan (misalnya CEO, Direktur dll)."
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Tingkat di mana Mata Uang Pelanggan dikonversi ke mata uang dasar pelanggan
DocType: Course Scheduling Tool,Course Scheduling Tool,Tentu saja Penjadwalan Perangkat
apps/erpnext/erpnext/controllers/accounts_controller.py +622,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Pembelian Faktur tidak dapat dilakukan terhadap aset yang ada {1}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Penting] Kesalahan saat membuat perulangan %s untuk %s
DocType: Land Unit,LInked Analysis,Analisis LInked
DocType: Item Tax,Tax Rate,Tarif Pajak
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} sudah dialokasikan bagi Karyawan {1} untuk periode {2} ke {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +919,Select Item,Pilih Stok Barang
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141,Purchase Invoice {0} is already submitted,Faktur Pembelian {0} sudah Terkirim
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Row # {0}: Batch ada harus sama {1} {2}
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Dikonversi ke non-Grup
DocType: C-Form Invoice Detail,Invoice Date,Faktur Tanggal
DocType: GL Entry,Debit Amount,Jumlah Debit
apps/erpnext/erpnext/accounts/party.py +251,There can only be 1 Account per Company in {0} {1},Hanya ada 1 Akun per Perusahaan di {0} {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,Silakan lihat lampiran
DocType: Purchase Order,% Received,% Diterima
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Buat Grup Mahasiswa
DocType: Volunteer,Weekends,Akhir pekan
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Jumlah Catatan Kredit
DocType: Setup Progress Action,Action Document,Dokumen tindakan
DocType: Chapter Member,Website URL,URL situs
,Finished Goods,Stok Barang Jadi
DocType: Delivery Note,Instructions,Instruksi
DocType: Quality Inspection,Inspected By,Diperiksa Oleh
DocType: Asset Maintenance Log,Maintenance Type,Tipe Pemeliharaan
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} tidak terdaftar di Kursus {2}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serial ada {0} bukan milik Pengiriman Note {1}
apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Tambahkan Item
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Stok Barang Kualitas Parameter Inspeksi
DocType: Leave Application,Leave Approver Name,Nama Approver Cuti
DocType: Depreciation Schedule,Schedule Date,Jadwal Tanggal
apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Laba, Pengurangan dan komponen Gaji lainnya"
DocType: Packed Item,Packed Item,Stok Barang Kemasan
apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Pengaturan default untuk transaksi Pembelian.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Terdapat Biaya Kegiatan untuk Karyawan {0} untuk Jenis Kegiatan - {1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Wajib lapangan - Dapatkan Siswa Dari
DocType: Program Enrollment,Enrolled courses,Kursus yang terdaftar
DocType: Currency Exchange,Currency Exchange,Kurs Mata Uang
DocType: Opening Invoice Creation Tool Item,Item Name,Nama Item
DocType: Authorization Rule,Approving User  (above authorized value),Approving User (di atas nilai yang berwenang)
DocType: Email Digest,Credit Balance,Saldo kredit
DocType: Employee,Widowed,Janda
DocType: Request for Quotation,Request for Quotation,Permintaan Quotation
DocType: Healthcare Settings,Require Lab Test Approval,Memerlukan Lab Test Approval
DocType: Salary Slip Timesheet,Working Hours,Jam Kerja
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Total Posisi
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Mengubah mulai / nomor urut saat ini dari seri yang ada.
DocType: Dosage Strength,Strength,Kekuatan
apps/erpnext/erpnext/accounts/page/pos/pos.js +1524,Create a new Customer,Buat Pelanggan baru
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Jika beberapa Aturan Harga terus menang, pengguna akan diminta untuk mengatur Prioritas manual untuk menyelesaikan konflik."
apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Buat Purchase Order
,Purchase Register,Register Pembelian
DocType: Scheduling Tool,Rechedule,Rechedule
DocType: Landed Cost Item,Applicable Charges,Biaya yang Berlaku
DocType: Workstation,Consumable Cost,Biaya Consumable
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',{0} ({1}) harus memiliki akses sebagai 'Pemberi Izin Cuti'
DocType: Purchase Receipt,Vehicle Date,Tanggal Kendaraan
DocType: Student Log,Medical,Medis
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Alasan Kehilangan
apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Perbarui Nomor Akun
apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Pemilik Prospek tidak bisa sama dengan Prospek
apps/erpnext/erpnext/accounts/utils.py +356,Allocated amount can not greater than unadjusted amount,jumlah yang dialokasikan tidak bisa lebih besar dari jumlah yang disesuaikan
DocType: Announcement,Receiver,Penerima
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation ditutup pada tanggal berikut sesuai Hari Libur Daftar: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Peluang
DocType: Lab Test Template,Single,Tunggal
DocType: Salary Slip,Total Loan Repayment,Total Pembayaran Pinjaman
DocType: Account,Cost of Goods Sold,Harga Pokok Penjualan
DocType: Subscription,Yearly,Tahunan
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,Please enter Cost Center,Harap Masukan Jenis Biaya Pusat
DocType: Drug Prescription,Dosage,Dosis
DocType: Journal Entry Account,Sales Order,Order Penjualan
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Avg. Selling Rate,Harga Jual Rata-rata
DocType: Assessment Plan,Examiner Name,Nama pemeriksa
DocType: Lab Test Template,No Result,Tidak ada hasil
DocType: Purchase Invoice Item,Quantity and Rate,Kuantitas dan Harga
DocType: Delivery Note,% Installed,% Terpasang
apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,Ruang kelas / Laboratorium dll di mana kuliah dapat dijadwalkan.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Silahkan masukkan nama perusahaan terlebih dahulu
DocType: Purchase Invoice,Supplier Name,Nama Supplier
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Baca Pedoman ERPNEXT
DocType: Account,Is Group,Apakah Group?
DocType: Email Digest,Pending Purchase Orders,Pending Pembelian Pesanan
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Nomor Seri Otomatis berdasarkan FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Periksa keunikan nomor Faktur Supplier
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Rincian Alamat Utama
DocType: Vehicle Service,Oil Change,Ganti oli
DocType: Asset Maintenance Log,Asset Maintenance Log,Log pemeliharaan aset
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.','Sampai Kasus No.' tidak bisa kurang dari 'Dari Kasus No.'
DocType: Chapter,Non Profit,Non Profit
DocType: Production Order,Not Started,Tidak Dimulai
DocType: Lead,Channel Partner,Chanel Mitra
DocType: Account,Old Parent,Old Parent
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Bidang Wajib - Tahun Akademik
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} is not associated with {2} {3},{0} {1} tidak terkait dengan {2} {3}
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Sesuaikan teks pengantar yang menjadi bagian dari surel itu. Setiap transaksi memiliki teks pengantar yang terpisah.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +182,Please set default payable account for the company {0},Harap atur akun hutang default untuk perusahaan {0}
DocType: Setup Progress Action,Min Doc Count,Min Doc Count
apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Pengaturan global untuk semua proses manufaktur.
DocType: Accounts Settings,Accounts Frozen Upto,Akun dibekukan sampai dengan
DocType: SMS Log,Sent On,Dikirim Pada
apps/erpnext/erpnext/stock/doctype/item/item.py +671,Attribute {0} selected multiple times in Attributes Table,Atribut {0} karena beberapa kali dalam Atribut Tabel
DocType: HR Settings,Employee record is created using selected field. ,
DocType: Sales Order,Not Applicable,Tidak Berlaku
apps/erpnext/erpnext/config/hr.py +70,Holiday master.,master Hari Libur.
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +77,Opening Invoice Item,Membuka Item Faktur
DocType: Request for Quotation Item,Required Date,Diperlukan Tanggal
DocType: Delivery Note,Billing Address,Alamat Penagihan
DocType: BOM,Costing,Biaya
DocType: Tax Rule,Billing County,Daerah Penagihan
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Jika dicentang, jumlah pajak akan dianggap sebagai sudah termasuk dalam Jumlah Tingkat Cetak / Print"
DocType: Request for Quotation,Message for Supplier,Pesan Supplier
DocType: Driver,DRIVER-.#####,SOPIR-.#####
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Jumlah Qty
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,ID Email Guardian2
DocType: Item,Show in Website (Variant),Tampilkan Website (Variant)
DocType: Employee,Health Concerns,Kekhawatiran Kesehatan
DocType: Payroll Entry,Select Payroll Period,Pilih Payroll Periode
DocType: Purchase Invoice,Unpaid,Tunggakan
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Dicadangkan untuk dijual
apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Silakan setup Employee Naming System di Human Resource&gt; HR Settings
DocType: Packing Slip,From Package No.,Dari Package No
DocType: Item Attribute,To Range,Berkisar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Efek Saham dan Deposit
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Tidak dapat mengubah metode valuasi, karena ada transaksi terhadap beberapa item yang tidak memiliki metode penilaian sendiri"
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Jumlah cuti wajib dialokasikan
DocType: Patient,AB Positive,AB Positif
DocType: Job Opening,Description of a Job Opening,Deskripsi dari Lowongan Pekerjaan
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Pending activities for today,Kegiatan tertunda untuk hari ini
apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Laporan Absensi.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Komponen gaji untuk gaji berdasarkan absen.
DocType: Sales Order Item,Used for Production Plan,Digunakan untuk Rencana Produksi
DocType: Employee Loan,Total Payment,Total pembayaran
DocType: Manufacturing Settings,Time Between Operations (in mins),Waktu diantara Operasi (di menit)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +129,{0} {1} is cancelled so the action cannot be completed,{0} {1} dibatalkan sehingga tindakan tidak dapat diselesaikan
DocType: Customer,Buyer of Goods and Services.,Pembeli Stok Barang dan Jasa.
DocType: Journal Entry,Accounts Payable,Hutang
DocType: Patient,Allergies,Alergi
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +30,The selected BOMs are not for the same item,BOMs yang dipilih tidak untuk item yang sama
DocType: Supplier Scorecard Standing,Notify Other,Beritahu Lainnya
DocType: Vital Signs,Blood Pressure (systolic),Tekanan Darah (sistolik)
DocType: Pricing Rule,Valid Upto,Valid Upto
DocType: Training Event,Workshop,Bengkel
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Peringatkan untuk Pesanan Pembelian
apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Daftar beberapa pelanggan anda. Bisa organisasi atau individu.
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23,Enough Parts to Build,Bagian yang cukup untuk Membangun
DocType: POS Profile User,POS Profile User,Profil Pengguna POS
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Pendapatan Langsung
DocType: Patient Appointment,Date TIme,Tanggal Waktu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41,"Can not filter based on Account, if grouped by Account","Tidak dapat memfilter berdasarkan Account, jika dikelompokkan berdasarkan Account"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,Petugas Administrasi
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Menyiapkan perusahaan dan pajak
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Silakan pilih Kursus
DocType: Codification Table,Codification Table,Tabel Kodifikasi
DocType: Timesheet Detail,Hrs,Hrs
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +350,Please select Company,Silakan pilih Perusahaan
DocType: Stock Entry Detail,Difference Account,Perbedaan Akun
DocType: Purchase Invoice,Supplier GSTIN,Pemasok GSTIN
apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,Tidak bisa tugas sedekat tugas yang tergantung {0} tidak tertutup.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,Entrikan Gudang yang Material Permintaan akan dibangkitkan
DocType: Production Order,Additional Operating Cost,Biaya Operasi Tambahan
DocType: Lab Test Template,Lab Routine,Lab Rutin
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Kosmetik
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Silakan pilih Tanggal Penyelesaian untuk Pemeriksaan Pemeliharaan Aset Selesai
apps/erpnext/erpnext/stock/doctype/item/item.py +526,"To merge, following properties must be same for both items","Untuk bergabung, sifat berikut harus sama untuk kedua item"
DocType: Shipping Rule,Net Weight,Berat Bersih
DocType: Employee,Emergency Phone,Telepon Darurat
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Membeli
,Serial No Warranty Expiry,Nomor Serial Garansi telah kadaluarsa
DocType: Sales Invoice,Offline POS Name,POS Offline Nama
apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Aplikasi siswa
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Harap tentukan nilai untuk Threshold 0%
DocType: Sales Order,To Deliver,Mengirim
DocType: Purchase Invoice Item,Item,Barang
apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Sensitivitas tinggi
apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Informasi Tipe Sukarela.
apps/erpnext/erpnext/accounts/page/pos/pos.js +2513,Serial no item cannot be a fraction,Serial Item tidak dapat pecahan
DocType: Journal Entry,Difference (Dr - Cr),Perbedaan (Dr - Cr)
DocType: Account,Profit and Loss,Laba Rugi
DocType: Patient,Risk Factors,Faktor risiko
DocType: Patient,Occupational Hazards and Environmental Factors,Bahaya Kerja dan Faktor Lingkungan
DocType: Vital Signs,Respiratory rate,Tingkat pernapasan
apps/erpnext/erpnext/config/stock.py +330,Managing Subcontracting,Pengaturan Subkontrak
DocType: Vital Signs,Body Temperature,Suhu tubuh
DocType: Project,Project will be accessible on the website to these users,Proyek akan dapat diakses di website pengguna ini
DocType: Detected Disease,Disease,Penyakit
apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Tentukan jenis proyek.
DocType: Supplier Scorecard,Weighting Function,Fungsi pembobotan
DocType: Physician,OP Consulting Charge,OP Consulting Charge
apps/erpnext/erpnext/utilities/user_progress.py +25,Setup your ,Setup Anda
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Tingkat di mana mata uang Daftar Harga dikonversi ke mata uang dasar perusahaan
apps/erpnext/erpnext/setup/doctype/company/company.py +69,Account {0} does not belong to company: {1},Akun {0} bukan milik perusahaan: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Singkatan sudah digunakan untuk perusahaan lain
DocType: Selling Settings,Default Customer Group,Kelompok Pelanggan Standar
DocType: Asset Repair,ARLOG-,ARLOG-
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Jika disable, lapangan 'Rounded Jumlah' tidak akan terlihat dalam setiap transaksi"
DocType: BOM,Operating Cost,Biaya Operasi
DocType: Crop,Produced Items,Item yang Diproduksi
DocType: Sales Order Item,Gross Profit,Laba Kotor
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Kenaikan tidak bisa 0
DocType: Production Planning Tool,Material Requirement,Permintaan Material / Bahan
DocType: Company,Delete Company Transactions,Hapus Transaksi Perusahaan
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,Reference No and Reference Date is mandatory for Bank transaction,Referensi ada dan Tanggal referensi wajib untuk transaksi Bank
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Tambah / Edit Pajak dan Biaya
DocType: Payment Entry Reference,Supplier Invoice No,Nomor Faktur Supplier
DocType: Territory,For reference,Untuk referensi
DocType: Healthcare Settings,Appointment Confirmation,Konfirmasi perjanjian
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Tidak dapat menghapus No. Seri {0}, karena digunakan dalam transaksi persediaan"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +253,Closing (Cr),Penutup (Cr)
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Halo
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +110,Move Item,Pindahkan Barang
DocType: Serial No,Warranty Period (Days),Masa Garansi (Hari)
DocType: Installation Note Item,Installation Note Item,Laporan Instalasi Stok Barang
DocType: Production Plan Item,Pending Qty,Qty Tertunda
DocType: Budget,Ignore,Diabaikan
apps/erpnext/erpnext/accounts/party.py +384,{0} {1} is not active,{0} {1} tidak aktif
apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,dimensi penyiapan cek untuk pencetakan
DocType: Salary Slip,Salary Slip Timesheet,Daftar Absen Slip Gaji
apps/erpnext/erpnext/controllers/buying_controller.py +160,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Supplier Gudang wajib untuk Pembelian Penerimaan sub-kontrak
DocType: Pricing Rule,Valid From,Valid Dari
DocType: Sales Invoice,Total Commission,Jumlah Nilai Komisi
DocType: Pricing Rule,Sales Partner,Mitra Penjualan
apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Semua kartu pemilih Pemasok.
DocType: Buying Settings,Purchase Receipt Required,Diperlukan Nota Penerimaan
apps/erpnext/erpnext/stock/doctype/item/item.py +144,Valuation Rate is mandatory if Opening Stock entered,Tingkat Valuasi adalah wajib jika menggunakan Persediaan Pembukaan
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +142,No records found in the Invoice table,Tidak ada catatan yang ditemukan dalam tabel Faktur
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,Silakan pilih Perusahaan dan Partai Jenis terlebih dahulu
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Sudah menetapkan default pada profil pos {0} untuk pengguna {1}, dengan baik dinonaktifkan secara default"
apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Keuangan / akuntansi Tahun Berjalan
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Nilai akumulasi
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Maaf, Nomor Seri tidak dapat digabungkan"
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Wilayah Diperlukan di Profil POS
DocType: Supplier,Prevent RFQs,Mencegah RFQs
apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Membuat Sales Order
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Slip Gaji dikirim untuk periode dari {0} sampai {1}
DocType: Project Task,Project Task,Tugas Proyek
,Lead Id,Id Prospek
DocType: C-Form Invoice Detail,Grand Total,Nilai Jumlah Total
DocType: Assessment Plan,Course,kuliah
DocType: Timesheet,Payslip,payslip
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Item Cart
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Tahun Anggaran Tanggal Mulai tidak boleh lebih besar dari Fiscal Year End Tanggal
DocType: Issue,Resolution,Resolusi
DocType: C-Form,IV,IV
apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Terkirim: {0}
DocType: Expense Claim,Payable Account,Akun Hutang
DocType: Payment Entry,Type of Payment,Jenis Pembayaran
DocType: Sales Order,Billing and Delivery Status,Status Penagihan dan Pengiriman
DocType: Job Applicant,Resume Attachment,Lanjutkan Lampiran
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Pelanggan Rutin
DocType: Leave Control Panel,Allocate,Alokasi
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Buat Varian
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Membuka Invoice Creation Tool
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +851,Sales Return,Retur Penjualan
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Catatan: Jumlah daun dialokasikan {0} tidak boleh kurang dari daun yang telah disetujui {1} untuk periode
,Total Stock Summary,Ringkasan Persediaan Total
DocType: Announcement,Posted By,Dikirim oleh
DocType: Item,Delivered by Supplier (Drop Ship),Dikirim oleh Supplier (Drop Shipment)
DocType: Healthcare Settings,Confirmation Message,Pesan Konfirmasi
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Database pelanggan potensial.
DocType: Authorization Rule,Customer or Item,Pelanggan atau Produk
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Database Pelanggan.
DocType: Quotation,Quotation To,Penawaran Kepada
DocType: Lead,Middle Income,Penghasilan Menengah
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +225,Opening (Cr),Pembukaan (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py +835,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,Standar Satuan Ukur untuk Item {0} tidak dapat diubah secara langsung karena Anda telah membuat beberapa transaksi (s) dengan UOM lain. Anda akan perlu untuk membuat item baru menggunakan default UOM berbeda.
apps/erpnext/erpnext/accounts/utils.py +354,Allocated amount can not be negative,Jumlah yang dialokasikan tidak dijinkan negatif
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Harap atur Perusahaan
DocType: Purchase Order Item,Billed Amt,Nilai Tagihan
DocType: Training Result Employee,Training Result Employee,Pelatihan Hasil Karyawan
DocType: Warehouse,A logical Warehouse against which stock entries are made.,Suatu Gudang maya dimana entri persediaan dibuat.
DocType: Repayment Schedule,Principal Amount,Jumlah pokok
DocType: Employee Loan Application,Total Payable Interest,Total Utang Bunga
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Total Posisi: {0}
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Penjualan Faktur Timesheet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,Reference No & Reference Date is required for {0},Referensi ada & Referensi Tanggal diperlukan untuk {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Pilih Account Pembayaran untuk membuat Bank Masuk
apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Buat catatan Karyawan untuk mengelola daun, klaim biaya dan gaji"
DocType: Restaurant Reservation,Restaurant Reservation,Reservasi Restoran
DocType: Land Unit,Land Unit Name,Nama unit tanah
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Penulisan Proposal
DocType: Payment Entry Deduction,Payment Entry Deduction,Pembayaran Masuk Pengurangan
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Membungkus
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Beritahu Pelanggan via Email
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Sales Person lain {0} ada dengan id Karyawan yang sama
DocType: Employee Advance,Claimed Amount,Jumlah klaim
DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Jika dicentang, bahan baku untuk produk yang sub-kontrak akan dimasukkan dalam Permintaan Material"
apps/erpnext/erpnext/config/healthcare.py +62,Masters,Masters
DocType: Assessment Plan,Maximum Assessment Score,Skor Penilaian Maksimum
apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Perbarui Tanggal Transaksi Bank
apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Pelacakan waktu
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICATE FOR TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Baris {0} # Jumlah yang Dibayar tidak boleh lebih besar dari jumlah uang muka yang diminta
DocType: Fiscal Year Company,Fiscal Year Company,Tahun Fiskal Perusahaan
DocType: Packing Slip Item,DN Detail,DN Detil
DocType: Training Event,Conference,Konferensi
DocType: Timesheet,Billed,Ditagih
DocType: Batch,Batch Description,Kumpulan Keterangan
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Menciptakan kelompok siswa
apps/erpnext/erpnext/accounts/utils.py +727,"Payment Gateway Account not created, please create one manually.","Gateway Akun pembayaran tidak dibuat, silakan membuat satu secara manual."
DocType: Supplier Scorecard,Per Year,Per tahun
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Tidak memenuhi syarat untuk masuk dalam program ini sesuai DOB
DocType: Sales Invoice,Sales Taxes and Charges,Pajak Penjualan dan Biaya
DocType: Employee,Organization Profile,Profil Organisasi
DocType: Vital Signs,Height (In Meter),Tinggi (In Meter)
DocType: Student,Sibling Details,Detail saudara
DocType: Vehicle Service,Vehicle Service,Layanan kendaraan
apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Secara otomatis memicu permintaan umpan balik berdasarkan kondisi.
DocType: Employee,Reason for Resignation,Alasan pengunduran diri
apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Template untuk penilaian kinerja.
DocType: Sales Invoice,Credit Note Issued,Kredit Catatan Ditempatkan
DocType: Project Task,Weight,Berat
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktur / Jurnal entri Detail
apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} '{1}' tidak dalam Tahun Anggaran {2}
DocType: Buying Settings,Settings for Buying Module,Pengaturan untuk Modul Pembelian
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Aset {0} bukan milik perusahaan {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Cukup masukkan Nota Penerimaan terlebih dahulu
DocType: Buying Settings,Supplier Naming By,Penamaan Supplier Berdasarkan
DocType: Activity Type,Default Costing Rate,Standar Tingkat Biaya
DocType: Maintenance Schedule,Maintenance Schedule,Jadwal Pemeliharaan
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Kemudian Aturan Harga disaring berdasarkan Pelanggan, Kelompok Pelanggan, Wilayah, Pemasok, Jenis Pemasok, Kampanye, Mitra Penjualan, dll."
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Perubahan Nilai bersih dalam Persediaan
apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Manajemen Kredit Karyawan
DocType: Employee,Passport Number,Nomor Paspor
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Hubungan dengan Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Manajer
DocType: Payment Entry,Payment From / To,Pembayaran Dari / Untuk
apps/erpnext/erpnext/selling/doctype/customer/customer.py +156,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},batas kredit baru kurang dari jumlah yang luar biasa saat ini bagi pelanggan. batas kredit harus minimal {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428,Please set account in Warehouse {0},Harap setel akun di Gudang {0}
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,'Berdasarkan' dan 'Kelompokkan Menurut' tidak boleh sama
DocType: Sales Person,Sales Person Targets,Target Sales Person
DocType: Installation Note,IN-,DI-
DocType: Production Order Operation,In minutes,Dalam menit
DocType: Issue,Resolution Date,Tanggal Resolusi
DocType: Lab Test Template,Compound,Senyawa
DocType: Student Batch Name,Batch Name,Nama Kumpulan
DocType: Fee Validity,Max number of visit,Jumlah kunjungan maksimal
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Absen dibuat:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913,Please set default Cash or Bank account in Mode of Payment {0},Silakan set Cash standar atau rekening Bank Mode Pembayaran {0}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,Mendaftar
DocType: GST Settings,GST Settings,Pengaturan GST
DocType: Selling Settings,Customer Naming By,Penamaan Pelanggan Dengan
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Akan menampilkan siswa sebagai Hadir di Student Bulanan Kehadiran Laporan
DocType: Depreciation Schedule,Depreciation Amount,penyusutan Jumlah
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Konversikan ke Grup
DocType: Delivery Trip,TOUR-.#####,WISATA-.#####
DocType: Activity Cost,Activity Type,Jenis Kegiatan
DocType: Request for Quotation,For individual supplier,Untuk pemasok individual
DocType: BOM Operation,Base Hour Rate(Company Currency),Dasar Tarif Perjam (Mata Uang Perusahaan)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Jumlah Telah Terikirim
DocType: Company,Fixed Days,Hari Tetap
DocType: Quotation Item,Item Balance,Item Balance
DocType: Sales Invoice,Packing List,Packing List
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Order Pembelian yang diberikan kepada Supplier.
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Penerbitan
DocType: Activity Cost,Projects User,Pengguna Proyek
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Dikonsumsi
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} tidak ditemukan dalam tabel Rincian Tagihan
DocType: Asset,Asset Owner Company,Perusahaan Pemilik Aset
DocType: Company,Round Off Cost Center,Pembulatan Pusat Biaya
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Pemeliharaan Kunjungan {0} harus dibatalkan sebelum membatalkan Sales Order ini
DocType: Asset Maintenance Log,AML-,AML-
DocType: Item,Material Transfer,Transfer Barang
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Tidak dapat menemukan jalan untuk
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Dr),Pembukaan (Dr)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Posting timestamp harus setelah {0}
apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Membuat dokumen berulang
,GST Itemised Purchase Register,Daftar Pembelian Item GST
DocType: Course Scheduling Tool,Reschedule,Penjadwalan ulang
DocType: Employee Loan,Total Interest Payable,Total Utang Bunga
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Biaya Pajak dan Landing Cost
DocType: Production Order Operation,Actual Start Time,Waktu Mulai Aktual
DocType: BOM Operation,Operation Time,Waktu Operasi
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +316,Finish,Selesai
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Dasar
DocType: Timesheet,Total Billed Hours,Total Jam Ditagih
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1463,Write Off Amount,Jumlah Nilai Write Off
DocType: Leave Block List Allow,Allow User,Izinkan Pengguna
DocType: Journal Entry,Bill No,Nomor Tagihan
DocType: Company,Gain/Loss Account on Asset Disposal,Gain / Loss Account pada Asset Disposal
DocType: Vehicle Log,Service Details,Rincian layanan
DocType: Subscription,Quarterly,Triwulan
DocType: Lab Test Template,Grouped,Dikelompokkan
DocType: Selling Settings,Delivery Note Required,Nota Pengiriman Diperlukan
DocType: Bank Guarantee,Bank Guarantee Number,Nomor Bank Garansi
DocType: Assessment Criteria,Assessment Criteria,Kriteria penilaian
DocType: BOM Item,Basic Rate (Company Currency),Tarif Dasar (Mata Uang Perusahaan)
DocType: Student Attendance,Student Attendance,Kehadiran mahasiswa
DocType: Sales Invoice Timesheet,Time Sheet,Lembar waktu
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush Bahan Baku Berbasis Pada
DocType: Purchase Order Item Supplied,Reserve Warehouse,Gudang Cadangan
DocType: Lead,Lead is an Organization,Lead adalah sebuah Organisasi
DocType: Guardian Interest,Interest,Bunga
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Pra penjualan
DocType: Instructor Log,Other Details,Detail lainnya
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
DocType: Lab Test,Test Template,Uji Template
DocType: Restaurant Order Entry Item,Served,Melayani
apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Informasi pasal
DocType: Account,Accounts,Akun / Rekening
DocType: Vehicle,Odometer Value (Last),Odometer Nilai (terakhir)
apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Template dari kriteria scorecard pemasok.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Marketing
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,Entri pembayaran sudah dibuat
DocType: Request for Quotation,Get Suppliers,Dapatkan Pemasok
DocType: Purchase Receipt Item Supplied,Current Stock,Persediaan saat ini
apps/erpnext/erpnext/controllers/accounts_controller.py +609,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Aset {1} tidak terkait dengan Butir {2}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Slip Gaji Preview
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Akun {0} telah dimasukkan beberapa kali
DocType: Account,Expenses Included In Valuation,Biaya Termasuk di Dalam Penilaian Barang
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,Anda hanya bisa memperpanjang jika keanggotaan Anda akan berakhir dalam 30 hari
DocType: Land Unit,Longitude,Garis bujur
,Absent Student Report,Laporan Absen Siswa
DocType: Crop,Crop Spacing UOM,Tanaman Jarak UOM
DocType: Email Digest,Next email will be sent on:,Email berikutnya akan dikirim pada:
DocType: Offer Letter Term,Offer Letter Term,Term Surat Penawaran
DocType: Supplier Scorecard,Per Week,Per minggu
apps/erpnext/erpnext/stock/doctype/item/item.py +639,Item has variants.,Item memiliki varian.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Jumlah Siswa
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Item {0} tidak ditemukan
DocType: Bin,Stock Value,Nilai Persediaan
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,"Catatan biaya akan dibuat di latar belakang. Jika ada kesalahan, pesan kesalahan akan diperbarui dalam Jadwal."
apps/erpnext/erpnext/accounts/doctype/account/account.py +239,Company {0} does not exist,Perusahaan {0} tidak ada
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} memiliki validitas biaya sampai {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Jenis Tingkat Tree
DocType: BOM Explosion Item,Qty Consumed Per Unit,Kuantitas Dikonsumsi Per Unit
DocType: GST Account,IGST Account,Akun IGST
DocType: Serial No,Warranty Expiry Date,Tanggal Berakhir Garansi
DocType: Material Request Item,Quantity and Warehouse,Kuantitas dan Gudang
DocType: Hub Settings,Unregister,Unregister
DocType: Sales Invoice,Commission Rate (%),Komisi Rate (%)
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Silahkan pilih Program
DocType: Project,Estimated Cost,Estimasi biaya
DocType: Purchase Order,Link to material requests,Link ke permintaan bahan
DocType: Hub Settings,Publish,Menerbitkan
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Dirgantara
DocType: Journal Entry,Credit Card Entry,Entri Kartu Kredit
apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Perusahaan dan Account
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,Nilai
apps/erpnext/erpnext/utilities/transaction_base.py +33,Invalid Posting Time,Waktu posting tidak valid
DocType: Lead,Campaign Name,Nama Promosi Kampanye
DocType: Selling Settings,Close Opportunity After Days,Tutup Peluang Setelah Days
,Reserved,Ditahan
DocType: Driver,License Details,Rincian lisensi
DocType: Purchase Order,Supply Raw Materials,Pasokan Bahan Baku
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Aset Lancar
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +104,{0} is not a stock Item,{0} bukan Barang persediaan
apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Silakan bagikan umpan balik Anda ke pelatihan dengan mengklik &#39;Feedback Training&#39; dan kemudian &#39;New&#39;
DocType: Mode of Payment Account,Default Account,Akun Standar
apps/erpnext/erpnext/stock/doctype/item/item.py +262,Please select Sample Retention Warehouse in Stock Settings first,Silahkan pilih Sampel Retention Warehouse di Stock Settings terlebih dahulu
DocType: Payment Entry,Received Amount (Company Currency),Menerima Jumlah (Perusahaan Mata Uang)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,Prospek harus diatur apabila Peluang berasal dari Prospek
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Silakan pilih dari hari mingguan
DocType: Patient,O Negative,O negatif
DocType: Production Order Operation,Planned End Time,Rencana Waktu Berakhir
,Sales Person Target Variance Item Group-Wise,Sales Person Sasaran Variance Stok Barang Group-Wise
apps/erpnext/erpnext/accounts/doctype/account/account.py +93,Account with existing transaction cannot be converted to ledger,Akun dengan transaksi yang ada tidak dapat dikonversi ke buku besar
apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Rincian Jenis Memebership
DocType: Delivery Note,Customer's Purchase Order No,Nomor Order Pembelian Pelanggan
DocType: Budget,Budget Against,anggaran Terhadap
DocType: Employee,Cell Number,Nomor HP
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Tidak ada karyawan untuk kriteria yang diberikan. Periksa bahwa Slip Gaji belum pernah dibuat.
apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,Pembuatan Form Permintaan Material Otomatis
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Kalah
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,You can not enter current voucher in 'Against Journal Entry' column,Anda tidak dapat memasukkan voucher saat ini di kolom 'Terhadap Entri Jurnal'
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Dicadangkan untuk manufaktur
DocType: Soil Texture,Sand,Pasir
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Energi
DocType: Opportunity,Opportunity From,Peluang Dari
apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Laporan gaji bulanan.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +874,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Baris {0}: {1} Nomor seri diperlukan untuk Item {2}. Anda telah memberikan {3}.
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Silahkan pilih sebuah tabel
DocType: BOM,Website Specifications,Website Spesifikasi
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} adalah alamat email yang tidak valid di &#39;Penerima&#39;
DocType: Special Test Items,Particulars,Particulars
apps/erpnext/erpnext/config/healthcare.py +144,Antibiotic.,Antibiotika.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Dari {0} tipe {1}
DocType: Warranty Claim,CI-,cipher
apps/erpnext/erpnext/controllers/buying_controller.py +310,Row {0}: Conversion Factor is mandatory,Row {0}: Faktor Konversi adalah wajib
DocType: Student,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +326,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Beberapa Aturan Harga ada dengan kriteria yang sama, silahkan menyelesaikan konflik dengan menetapkan prioritas. Harga Aturan: {0}"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +504,Cannot deactivate or cancel BOM as it is linked with other BOMs,Tidak bisa menonaktifkan atau membatalkan BOM seperti yang terkait dengan BOMs lainnya
DocType: Asset,Maintenance,Pemeliharaan
DocType: Item Attribute Value,Item Attribute Value,Nilai Item Atribut
DocType: Item,Maximum sample quantity that can be retained,Jumlah sampel maksimal yang bisa dipertahankan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +398,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Baris {0} # Item {1} tidak dapat ditransfer lebih dari {2} terhadap Pesanan Pembelian {3}
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Kampanye penjualan.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,membuat Timesheet
DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Format pajak standar yang dapat diterapkan untuk semua Transaksi Penjualan. Format ini dapat berisi daftar kepala pajak dan juga kepala pengeluaran / penghasilan lain seperti ""Pengiriman"", ""Asuransi"", ""Penanganan"" dll. #### Catatan: Tarif pajak yang Anda definisikan disini akan menjadi tarif pajak standar untuk semua **Barang**. Jika ada **Barang** yang memiliki tarif yang berbeda, mereka harus ditambahkan ke dalam tabel **Pajak Barang** dalam daftar utama **Barang**. #### Deskripsi Kolom 1. Jenis Perhitungan: - Bisa berdasarkan **Jumlah Netto** (yaitu total dari jumlah dasar). - **Jumlah Baris Sebelumnya** (untuk pajak atau biaya kumulatif). Jika Anda memilih opsi ini, pajak akan diterapkan sebagai prosentase dari jumlah baris sebelumnya (dalam tabel pajak). - **Aktual** (seperti yang disebutkan). 2. Akun Kepala: Akun buku di mana pajak ini akan dibukukan. 3. Pusat Biaya: Jika pajak / ongkos adalah penghasilan (seperti pengiriman) atau beban maka harus dibukukan terhadap Pusat Biaya. 4. Keterangan: Deskripsi pajak (yang akan dicetak dalam faktur / penawaran). 5. Tarif: Tarif Pajak. 6. Jumlah: Jumlah Pajak. 7. Total: Total kumulatif sampai baris ini. 8. Baris Entri: Jika berdasarkan ""Jumlah Baris Sebelumnya"" Anda dapat memilih nomor baris yang akan diambil sebagai dasar perhitungan (standarnya adalah baris sebelumnya). 9. Apakah Pajak ini termasuk dalam Tarif Dasar?: Jika Anda tandai ini, berarti pajak ini tidak akan ditampilkan di bawah tabel barang, tapi akan dimasukkan dalam Tarif Dasar dalam tabel utama barang Anda. Hal ini berguna jika Anda ingin memberikan harga datar /flat price (semua pajak sudah termasuk) untuk pelanggan."
DocType: Employee,Bank A/C No.,Rekening Bank No.
DocType: Bank Guarantee,Project,Proyek
DocType: Quality Inspection Reading,Reading 7,Membaca 7
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,sebagian Memerintahkan
DocType: Lab Test,Lab Test,Uji Lab
DocType: Expense Claim Detail,Expense Claim Type,Tipe Beban Klaim
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Pengaturan default untuk Belanja
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Tambahkan Timeslots
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Aset membatalkan via Journal Entri {0}
DocType: Employee Loan,Interest Income Account,Akun Pendapatan Bunga
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Tinjau Undangan Dikirim
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Bioteknologi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Beban Pemeliharaan Kantor
apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Pergi ke
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Mengatur Akun Email
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,Entrikan Stok Barang terlebih dahulu
DocType: Asset Repair,Downtime,Downtime
DocType: Account,Liability,Kewajiban
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +234,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sanksi Jumlah tidak dapat lebih besar dari Klaim Jumlah dalam Row {0}.
DocType: Salary Detail,Do not include in total,Jangan termasuk secara total
DocType: Company,Default Cost of Goods Sold Account,Standar Harga Pokok Penjualan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +997,Sample quantity {0} cannot be more than received quantity {1},Kuantitas sampel {0} tidak boleh lebih dari jumlah yang diterima {1}
apps/erpnext/erpnext/stock/get_item_details.py +367,Price List not selected,Daftar Harga tidak dipilih
DocType: Employee,Family Background,Latar Belakang Keluarga
DocType: Request for Quotation Supplier,Send Email,Kirim Email
apps/erpnext/erpnext/stock/doctype/item/item.py +218,Warning: Invalid Attachment {0},Peringatan: Lampiran tidak valid {0}
DocType: Item,Max Sample Quantity,Jumlah Kuantitas Maks
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +764,No Permission,Tidak ada Izin
apps/erpnext/erpnext/hub_node/page/hub/hub.js +438,Quote Requested,Permintaan Kutipan
DocType: Vital Signs,Heart Rate / Pulse,Heart Rate / Pulse
DocType: Company,Default Bank Account,Standar Rekening Bank
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +55,"To filter based on Party, select Party Type first","Untuk menyaring berdasarkan Party, pilih Partai Ketik terlebih dahulu"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},'Pembaruan Persediaan’ tidak dapat dipilih karena barang tidak dikirim melalui {0}
DocType: Vehicle,Acquisition Date,Tanggal akuisisi
apps/erpnext/erpnext/utilities/user_progress.py +143,Nos,Nos
DocType: Item,Items with higher weightage will be shown higher,Item dengan weightage lebih tinggi akan ditampilkan lebih tinggi
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Tes Laboratorium dan Tanda Vital
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Rincian Rekonsiliasi Bank
apps/erpnext/erpnext/controllers/accounts_controller.py +613,Row #{0}: Asset {1} must be submitted,Row # {0}: Aset {1} harus diserahkan
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Tidak ada karyawan yang ditemukan
DocType: Subscription,Stopped,Terhenti
DocType: Item,If subcontracted to a vendor,Jika subkontrak ke pemasok
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Kelompok Siswa sudah diperbarui.
DocType: SMS Center,All Customer Contact,Semua Kontak Pelanggan
DocType: Land Unit,Tree Details,Detail pohon
DocType: Training Event,Event Status,Status acara
DocType: Volunteer,Availability Timeslot,Ketersediaan Timeslot
,Support Analytics,Dukungan Analytics
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Jika Anda memiliki pertanyaan, silakan kembali ke kami."
DocType: Item,Website Warehouse,Situs Gudang
DocType: Payment Reconciliation,Minimum Invoice Amount,Nilai Minimum Faktur
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Pusat Biaya {2} bukan milik Perusahaan {3}
apps/erpnext/erpnext/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Upload kepala surat Anda (Jaga agar web semudah 900px dengan 100px)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Akun {2} tidak boleh Kelompok
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Item Row {idx}: {doctype} {DOCNAME} tidak ada di atas &#39;{doctype}&#39; table
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +284,Timesheet {0} is already completed or cancelled,Absen {0} sudah selesai atau dibatalkan
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Tidak ada tugas
DocType: Item Variant Settings,Copy Fields to Variant,Copy Fields ke Variant
DocType: Asset,Opening Accumulated Depreciation,Membuka Penyusutan Akumulasi
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Skor harus kurang dari atau sama dengan 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Program Pendaftaran Alat
apps/erpnext/erpnext/config/accounts.py +335,C-Form records,C-Form catatan
apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Pelanggan dan Pemasok
DocType: Email Digest,Email Digest Settings,Pengaturan Surel Ringkasan
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +354,Thank you for your business!,Terima kasih untuk bisnis Anda!
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Permintaan dukungan dari pelanggan.
DocType: Setup Progress Action,Action Doctype,Doctype Aksi
,Production Order Stock Report,Laporan Persediaan Pesanan Produksi
apps/erpnext/erpnext/config/healthcare.py +149,Sensitivity Naming.,Sensitivitas Penamaan.
DocType: HR Settings,Retirement Age,Umur pensiun
DocType: Bin,Moving Average Rate,Tingkat Moving Average
DocType: Production Planning Tool,Select Items,Pilih Produk
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +370,{0} against Bill {1} dated {2},{0} terhadap Tagihan {1} tanggal {2}
apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Lembaga Penyiapan
DocType: Program Enrollment,Vehicle/Bus Number,Kendaraan / Nomor Bus
apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Jadwal Kuliah
DocType: Request for Quotation Supplier,Quote Status,Status Penawaran
DocType: Maintenance Visit,Completion Status,Status Penyelesaian
DocType: HR Settings,Enter retirement age in years,Memasuki usia pensiun di tahun
DocType: Crop,Target Warehouse,Target Gudang
DocType: Payroll Employee Detail,Payroll Employee Detail,Daftar gaji karyawan
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,Silahkan pilih gudang
DocType: Cheque Print Template,Starting location from left edge,Mulai lokasi dari tepi kiri
DocType: Item,Allow over delivery or receipt upto this percent,Biarkan selama pengiriman atau penerimaan upto persen ini
DocType: Stock Entry,STE-,Ste-
DocType: Upload Attendance,Import Attendance,Impor Absensi
apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Semua Grup Stok Barang/Item
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Laba / Rugi
apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Secara otomatis menulis pesan pada pengajuan transaksi.
DocType: Production Order,Item To Manufacture,Stok Barang Untuk Produksi
apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} status adalah {2}
DocType: Water Analysis,Collection Temperature ,Suhu Koleksi
DocType: Employee,Provide Email Address registered in company,Sediakan Alamat Email yang terdaftar di perusahaan
DocType: Shopping Cart Settings,Enable Checkout,aktifkan Checkout
apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Order Pembelian untuk Dibayar
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Proyeksi Qty
DocType: Sales Invoice,Payment Due Date,Tanggal Jatuh Tempo Pembayaran
DocType: Drug Prescription,Interval UOM,Interval UOM
apps/erpnext/erpnext/stock/doctype/item/item.js +490,Item Variant {0} already exists with same attributes,Item Varian {0} sudah ada dengan atribut yang sama
DocType: Item,Hub Publishing Details,Rincian Hub Publishing
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening','Awal'
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Terbuka yang Harus Dilakukan
DocType: Notification Control,Delivery Note Message,Pesan Nota Pengiriman
DocType: Lab Test Template,Result Format,Format Hasil
DocType: Expense Claim,Expenses,Biaya / Beban
DocType: Delivery Stop,Delivery Notes,Catatan pengiriman
DocType: Item Variant Attribute,Item Variant Attribute,Item Varian Atribut
,Purchase Receipt Trends,Tren Nota Penerimaan
DocType: Payroll Entry,Bimonthly,Dua bulan sekali
DocType: Vehicle Service,Brake Pad,Bantalan Rem
DocType: Fertilizer,Fertilizer Contents,Isi pupuk
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Penelitian & Pengembangan
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Nilai Tertagih
DocType: Company,Registration Details,Detail Pendaftaran
DocType: Timesheet,Total Billed Amount,Jumlah Total Ditagih
DocType: Item Reorder,Re-Order Qty,Re-order Qty
DocType: Leave Block List Date,Leave Block List Date,Tanggal Block List Cuti
DocType: Pricing Rule,Price or Discount,Harga atau Diskon
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +91,BOM #{0}: Raw material cannot be same as main Item,BOM #{0}: Bahan baku tidak boleh sama dengan Barang utamanya
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Total Biaya Berlaku di Purchase meja Jenis Penerimaan harus sama dengan jumlah Pajak dan Biaya
DocType: Sales Team,Incentives,Insentif
apps/erpnext/erpnext/hub_node/page/hub/hub.js +64,Register for Hub,Mendaftar untuk Hub
DocType: SMS Log,Requested Numbers,Nomor yang Diminta
DocType: Volunteer,Evening,Malam
DocType: Production Planning Tool,Only Obtain Raw Materials,Hanya Mendapatkan Bahan Baku
DocType: Customer,Bypass credit limit check at Sales Order,Bataskan cek batas kredit pada Sales Order
apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Penilaian kinerja.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Mengaktifkan &#39;Gunakan untuk Keranjang Belanja&#39;, sebagai Keranjang Belanja diaktifkan dan harus ada setidaknya satu Rule Pajak untuk Belanja"
apps/erpnext/erpnext/controllers/accounts_controller.py +411,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Masuk pembayaran {0} terkait terhadap Orde {1}, memeriksa apakah itu harus ditarik sebagai uang muka dalam faktur ini."
DocType: Sales Invoice Item,Stock Details,Rincian Persediaan
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Nilai Proyek
apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,POS
DocType: Fee Schedule,Fee Creation Status,Status Penciptaan Biaya
DocType: Vehicle Log,Odometer Reading,Pembacaan odometer
apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Saldo rekening telah berada di Kredit, Anda tidak diizinkan untuk mengatur 'Balance Harus' sebagai 'Debit'"
DocType: Account,Balance must be,Saldo harus
DocType: Hub Settings,Publish Pricing,Publikasikan Harga
DocType: Notification Control,Expense Claim Rejected Message,Beban Klaim Ditolak Pesan
,Available Qty,Qty Tersedia
DocType: Purchase Taxes and Charges,On Previous Row Total,Jumlah Pada Row Sebelumnya
DocType: Purchase Invoice Item,Rejected Qty,ditolak Qty
DocType: Setup Progress Action,Action Field,Bidang Aksi
DocType: Healthcare Settings,Manage Customer,Kelola Pelanggan
DocType: Delivery Trip,Delivery Stops,Pengiriman Berhenti
DocType: Salary Slip,Working Days,Hari Kerja
DocType: Serial No,Incoming Rate,Harga Penerimaan
DocType: Packing Slip,Gross Weight,Berat Kotor
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Aktifkan Hub
apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,Nama perusahaan Anda yang Anda sedang mengatur sistem ini.
DocType: HR Settings,Include holidays in Total no. of Working Days,Sertakan Hari Libur di total no. dari Hari Kerja
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Siapkan Institut Anda di ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Analisis Tanaman
DocType: Job Applicant,Hold,Ditahan
DocType: Employee,Date of Joining,Tanggal Bergabung
DocType: Naming Series,Update Series,Perbarui Seri
DocType: Supplier Quotation,Is Subcontracted,Apakah Subkontrak?
DocType: Restaurant Table,Minimum Seating,Tempat Duduk Minimal
DocType: Item Attribute,Item Attribute Values,Item Nilai Atribut
DocType: Examination Result,Examination Result,Hasil pemeriksaan
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +843,Purchase Receipt,Nota Penerimaan
,Received Items To Be Billed,Produk Diterima Akan Ditagih
apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Master Nilai Mata Uang
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +198,Reference Doctype must be one of {0},Referensi DOCTYPE harus menjadi salah satu {0}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},Tidak dapat menemukan waktu Slot di {0} hari berikutnya untuk Operasi {1}
DocType: Production Order,Plan material for sub-assemblies,Planning Material untuk Barang Rakitan
apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Mitra Penjualan dan Wilayah
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +585,BOM {0} must be active,BOM {0} harus aktif
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +193,Closing (Opening + Total),Penutupan (Pembukaan + Total)
DocType: Journal Entry,Depreciation Entry,penyusutan Masuk
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Silakan pilih jenis dokumen terlebih dahulu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +111,Print in Account Currency,Cetak dalam Mata Uang Akun
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Batal Kunjungan Material {0} sebelum membatalkan ini Maintenance Visit
DocType: Crop Cycle,ISO 8016 standard,Standar ISO 8016
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Serial ada {0} bukan milik Stok Barang {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Qty Diperlukan
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Gudang dengan transaksi yang ada tidak dapat dikonversi ke buku besar.
DocType: Bank Reconciliation,Total Amount,Nilai Total
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Penerbitan Internet
DocType: Prescription Duration,Number,Jumlah
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Membuat {0} Faktur
DocType: Medical Code,Medical Code Standard,Standar Kode Medis
DocType: Soil Texture,Clay Composition (%),Komposisi Tanah Liar (%)
DocType: Production Planning Tool,Production Orders,Order Produksi
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Harap simpan sebelum menugaskan tugas.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Balance Value,Nilai Saldo
DocType: Lab Test,Lab Technician,Teknisi laboratorium
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Daftar Harga Jual
DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Jika dicek, pelanggan akan dibuat, dipetakan ke Patient. Faktur pasien akan dibuat terhadap Nasabah ini. Anda juga bisa memilih Customer yang ada saat membuat Patient."
DocType: Bank Reconciliation,Account Currency,Mata Uang Akun
DocType: Lab Test,Sample ID,Contoh ID
apps/erpnext/erpnext/accounts/general_ledger.py +165,Please mention Round Off Account in Company,Sebutkan Round Off Akun/ Akun Pembulatan di Perusahaan
DocType: Purchase Receipt,Range,Jarak
DocType: Supplier,Default Payable Accounts,Standar Akun Hutang
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Karyawan {0} tidak aktif atau tidak ada
DocType: Fee Structure,Components,komponen
apps/erpnext/erpnext/assets/doctype/asset/asset.py +276,Please enter Asset Category in Item {0},Cukup masukkan Aset Kategori dalam angka {0}
apps/erpnext/erpnext/stock/doctype/item/item.py +634,Item Variants {0} updated,Varian Barang {0} diperbarui
DocType: Quality Inspection Reading,Reading 6,Membaca 6
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
of this","untuk dihasilkan. Jika tertunda, Anda harus mengubah secara manual bidang ""Ulangi pada Hari di Bulan"" ini"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,Tidak bisa {0} {1} {2} tanpa faktur yang beredar negatif
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Uang Muka Faktur Pembelian
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +197,Row {0}: Credit entry can not be linked with a {1},Baris {0}: entry Kredit tidak dapat dihubungkan dengan {1}
apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Tentukan anggaran untuk tahun keuangan.
DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Akun standar Bank / Cash akan secara otomatis diperbarui di Faktur POS saat mode ini dipilih.
DocType: Lead,LEAD-,PROSPEK-
DocType: Employee,Permanent Address Is,Alamat Permanen Adalah:
DocType: Production Order Operation,Operation completed for how many finished goods?,Operasi selesai untuk berapa banyak Stok Barang jadi?
DocType: Payment Terms Template,Payment Terms Template,Template Persyaratan Pembayaran
apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Merek
DocType: Employee,Exit Interview Details,Detail Exit Interview
DocType: Item,Is Purchase Item,Stok Dibeli dari Supplier
DocType: Journal Entry Account,Purchase Invoice,Faktur Pembelian
DocType: Stock Ledger Entry,Voucher Detail No,Nomor Detail Voucher
apps/erpnext/erpnext/accounts/page/pos/pos.js +781,New Sales Invoice,Baru Faktur Penjualan
DocType: Stock Entry,Total Outgoing Value,Nilai Total Keluaran
DocType: Physician,Appointments,Janji
apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Tanggal dan Closing Date membuka harus berada dalam Tahun Anggaran yang sama
DocType: Lead,Request for Information,Request for Information
,LeaderBoard,LeaderBoard
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Tingkat Dengan Margin (Mata Uang Perusahaan)
apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Offline Invoices,Sinkronisasi Offline Faktur
DocType: Payment Request,Paid,Dibayar
DocType: Program Fee,Program Fee,Biaya Program
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.","Ganti BOM tertentu di semua BOM lain yang menggunakannya. Hal ini akan mengganti link BOM lama, memperbarui biaya dan membuat ulang tabel ""Rincian Barang BOM"" sesuai BOM baru. Juga memperbarui harga terbaru di semua BOM."
DocType: Salary Slip,Total in words,Jumlah kata
DocType: Material Request Item,Lead Time Date,Tanggal Masa Tenggang
DocType: Guardian,Guardian Name,Nama wali
DocType: Cheque Print Template,Has Print Format,Memiliki Print Format
DocType: Employee Loan,Sanctioned,sanksi
apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,wajib diisi. Mungkin Kurs Mata Uang belum dibuat untuk
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +122,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Silakan tentukan Serial ada untuk Item {1}
DocType: Crop Cycle,Crop Cycle,Siklus Tanaman
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +632,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Untuk barang-barang 'Bundel Produk', Gudang, Nomor Serial dan Nomor Batch akan diperhitungkan dari tabel 'Packing List'. Bila Gudang dan Nomor Batch sama untuk semua barang-barang kemasan dari segala barang 'Bundel Produk', maka nilai tersebut dapat dimasukkan dalam tabel Barang utama, nilai tersebut akan disalin ke tabel 'Packing List'."
DocType: Student Admission,Publish on website,Mempublikasikan di website
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,Supplier Invoice Date cannot be greater than Posting Date,Pemasok Faktur Tanggal tidak dapat lebih besar dari Posting Tanggal
DocType: Purchase Invoice Item,Purchase Order Item,Stok Barang Order Pembelian
DocType: Agriculture Task,Agriculture Task,Tugas Pertanian
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Pendapatan Tidak Langsung
DocType: Student Attendance Tool,Student Attendance Tool,Alat Kehadiran Siswa
DocType: Restaurant Menu,Price List (Auto created),Daftar Harga (Auto dibuat)
DocType: Cheque Print Template,Date Settings,Pengaturan Tanggal
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Variance
,Company Name,Nama Perusahaan
DocType: SMS Center,Total Message(s),Total Pesan (s)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +917,Select Item for Transfer,Pilih item untuk transfer
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Harap tentukan Seri Penamaan untuk {0} melalui Setup&gt; Settings&gt; Naming Series
DocType: Purchase Invoice,Additional Discount Percentage,Persentase Diskon Tambahan
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Lihat daftar semua bantuan video
DocType: Agriculture Analysis Criteria,Soil Texture,Tekstur Tanah
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Pilih kepala rekening bank mana cek diendapkan.
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Izinkan user/pengguna untuk mengubah rate daftar harga di dalam transaksi
DocType: Pricing Rule,Max Qty,Qty Maksimum
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
						Please enter a valid Invoice","Row {0}: Faktur {1} tidak valid, mungkin dibatalkan / tidak ada. \ Masukkan Faktur valid"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Baris {0}: Pembayaran terhadap Penjualan / Purchase Order harus selalu ditandai sebagai muka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Kimia
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Akun standar Bank / Cash akan otomatis diperbarui di Entri Jurnal Gaji saat mode ini dipilih.
DocType: BOM,Raw Material Cost(Company Currency),Biaya Bahan Baku (Perusahaan Mata Uang)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +775,All items have already been transferred for this Production Order.,Semua item telah dialihkan untuk Order Produksi ini.
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Baris # {0}: Tarif tidak boleh lebih besar dari tarif yang digunakan di {1} {2}
apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,Meter
DocType: Workstation,Electricity Cost,Biaya Listrik
DocType: HR Settings,Don't send Employee Birthday Reminders,Jangan Kirim Pengingat Ulang Tahun
DocType: Expense Claim,Total Advance Amount,Jumlah Uang Muka Total
DocType: Delivery Stop,Estimated Arrival,perkiraan kedatangan
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Simpan Pengaturan
DocType: Delivery Stop,Notified by Email,Diberitahukan melalui email
apps/erpnext/erpnext/hub_node/page/hub/hub.js +683,Requested Products,Produk yang diminta
DocType: Item,Inspection Criteria,Kriteria Inspeksi
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Ditransfer
DocType: BOM Website Item,BOM Website Item,BOM Situs Persediaan
apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Unggah kop surat dan logo. (Anda dapat mengubahnya nanti).
DocType: Timesheet Detail,Bill,Tagihan
apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date is entered as past date,Berikutnya Penyusutan Tanggal dimasukkan sebagai tanggal terakhir
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Putih
DocType: SMS Center,All Lead (Open),Semua Prospek (Terbuka)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Row {0}: Qty tidak tersedia untuk {4} di gudang {1} pada postingan kali entri ({2} {3})
DocType: Purchase Invoice,Get Advances Paid,Dapatkan Uang Muka Dibayar
DocType: Item,Automatically Create New Batch,Buat Batch Baru secara otomatis
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Make ,Membuat
DocType: Student Admission,Admission Start Date,Pendaftaran Mulai Tanggal
DocType: Journal Entry,Total Amount in Words,Jumlah Total dalam Kata
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Karyawan baru
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,Ada kesalahan. Salah satu alasan yang mungkin bisa jadi Anda belum menyimpan formulir. Silahkan hubungi support@erpnext.com jika masalah terus berlanjut.
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Cart saya
apps/erpnext/erpnext/controllers/selling_controller.py +129,Order Type must be one of {0},Order Type harus menjadi salah satu {0}
DocType: Lead,Next Contact Date,Tanggal Komunikasi Selanjutnya
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Qty Pembukaan
DocType: Healthcare Settings,Appointment Reminder,Pengingat Penunjukan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +465,Please enter Account for Change Amount,Silahkan masukkan account untuk Perubahan Jumlah
DocType: Program Enrollment Tool Student,Student Batch Name,Mahasiswa Nama Batch
DocType: Consultation,Doctor,Dokter
DocType: Holiday List,Holiday List Name,Daftar Nama Hari Libur
DocType: Repayment Schedule,Balance Loan Amount,Saldo Jumlah Pinjaman
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Jadwal Kursus
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Stock Options,Opsi Persediaan
DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Nonaktifkan Mengambil Rincian Pembelian Terakhir di Pesanan Pembelian
DocType: Journal Entry Account,Expense Claim,Biaya Klaim
apps/erpnext/erpnext/assets/doctype/asset/asset.js +254,Do you really want to restore this scrapped asset?,Apakah Anda benar-benar ingin mengembalikan aset dibuang ini?
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Qty for {0},Kuantitas untuk {0}
DocType: Leave Application,Leave Application,Aplikasi Cuti
DocType: Patient,Patient Relation,Hubungan Pasien
apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Alat Alokasi Cuti
DocType: Item,Hub Category to Publish,Kategori Hub untuk Publikasikan
DocType: Leave Block List,Leave Block List Dates,Tanggal Blok List Cuti
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Silakan setup seri penomoran untuk Kehadiran melalui Setup&gt; Numbering Series
DocType: Sales Invoice,Billing Address GSTIN,Alamat Penagihan GSTIN
DocType: Assessment Plan,Evaluate,Evaluasi
DocType: Workstation,Net Hour Rate,Jumlah Jam Bersih
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Biaya Landing Cost Nota Penerimaan
DocType: Company,Default Terms,Persyaratan Standar
DocType: Supplier Scorecard Period,Criteria,Kriteria
DocType: Packing Slip Item,Packing Slip Item,Packing Slip Stok Barang
DocType: Purchase Invoice,Cash/Bank Account,Rekening Kas / Bank
apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Tentukan {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73,Removed items with no change in quantity or value.,Item dihapus dengan tidak ada perubahan dalam jumlah atau nilai.
DocType: Delivery Note,Delivery To,Pengiriman Untuk
apps/erpnext/erpnext/stock/doctype/item/item.js +384,Variant creation has been queued.,Pembuatan varian telah antri.
apps/erpnext/erpnext/stock/doctype/item/item.py +668,Attribute table is mandatory,Tabel atribut wajib
DocType: Production Planning Tool,Get Sales Orders,Dapatkan Order Penjualan
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} tidak dapat negatif
DocType: Training Event,Self-Study,Belajar sendiri
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +544,Discount,Diskon
DocType: Membership,Membership,Keanggotaan
DocType: Asset,Total Number of Depreciations,Total Jumlah Penyusutan
DocType: Sales Invoice Item,Rate With Margin,Tingkat Dengan Margin
DocType: Workstation,Wages,Upah
DocType: Asset Maintenance,Maintenance Manager Name,Nama Manajer Pemeliharaan
DocType: Agriculture Task,Urgent,Mendesak
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Tentukan Row ID berlaku untuk baris {0} dalam tabel {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Tidak dapat menemukan variabel:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +746,Please select a field to edit from numpad,Harap pilih bidang yang akan diedit dari numpad
apps/erpnext/erpnext/stock/doctype/item/item.py +253,Cannot be a fixed asset item as Stock Ledger is created.,Tidak dapat menjadi item aset tetap karena Stock Ledger dibuat.
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Pergi ke Desktop dan mulai menggunakan ERPNext
DocType: Item,Manufacturer,Pabrikasi
DocType: Landed Cost Item,Purchase Receipt Item,Nota Penerimaan Stok Barang
DocType: Purchase Receipt,PREC-RET-,Prec-RET-
DocType: POS Profile,Sales Invoice Payment,Pembayaran Faktur Penjualan
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Reserved Gudang di Sales Order / Stok Barang Jadi Gudang
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Selling Amount,Nilai Penjualan
DocType: Repayment Schedule,Interest Amount,Jumlah bunga
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +120,You are the Expense Approver for this record. Please Update the 'Status' and Save,Anda adalah Penyetuju data ini. Harap Perbarui 'Status' dan Simpan
DocType: Serial No,Creation Document No,Nomor Dokumen
DocType: Issue,Issue,Masalah / Isu
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Catatan
DocType: Asset,Scrapped,membatalkan
DocType: Purchase Invoice,Returns,Retur
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP Gudang
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serial ada {0} berada di bawah kontrak pemeliharaan upto {1}
apps/erpnext/erpnext/config/hr.py +35,Recruitment,Pengerahan
DocType: Lead,Organization Name,Nama Organisasi
DocType: Tax Rule,Shipping State,Negara Pengirim
,Projected Quantity as Source,Proyeksi Jumlah sebagai Sumber
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,Item harus ditambahkan dengan menggunakan 'Dapatkan Produk dari Pembelian Penerimaan' tombol
DocType: Delivery Trip,Delivery Trip,Perjalanan pengiriman
DocType: Student,A-,A-
DocType: Production Planning Tool,Include non-stock items,Termasuk item non-persediaan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Beban Penjualan
DocType: Consultation,Diagnosis,Diagnosa
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standar Pembelian
DocType: GL Entry,Against,Terhadap
DocType: Item,Default Selling Cost Center,Standar Pusat Biaya Jual
DocType: Sales Partner,Implementation Partner,Mitra Implementasi
apps/erpnext/erpnext/accounts/page/pos/pos.js +1614,ZIP Code,Kode Pos
apps/erpnext/erpnext/controllers/selling_controller.py +248,Sales Order {0} is {1},Sales Order {0} adalah {1}
DocType: Opportunity,Contact Info,Informasi Kontak
apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Membuat Entri Persediaan
DocType: Packing Slip,Net Weight UOM,Uom Berat Bersih
DocType: Item,Default Supplier,Supplier Standar
DocType: Manufacturing Settings,Over Production Allowance Percentage,Selama Penyisihan Produksi Persentase
DocType: Employee Loan,Repayment Schedule,Jadwal pembayaran
DocType: Shipping Rule Condition,Shipping Rule Condition,Kondisi / Aturan Pengiriman
DocType: Holiday List,Get Weekly Off Dates,Dapatkan Tanggal Libur Mingguan
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Tanggal Berakhir tidak boleh lebih awal dari Tanggal Mulai
DocType: Sales Person,Select company name first.,Pilih nama perusahaan terlebih dahulu.
apps/erpnext/erpnext/hub_node/page/hub/hub.js +181,Low to High,Rendah ke tinggi
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +202,Email sent to {0},Email dikirim ke {0}
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Penawaran Diterima dari Supplier
apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Ganti BOM dan perbarui harga terbaru di semua BOM
apps/erpnext/erpnext/controllers/selling_controller.py +27,To {0} | {1} {2},Untuk {0} | {1} {2}
DocType: Delivery Trip,Driver Name,Nama pengemudi
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Rata-rata Usia
DocType: Education Settings,Attendance Freeze Date,Tanggal Pembekuan Kehadiran
apps/erpnext/erpnext/utilities/user_progress.py +107,List a few of your suppliers. They could be organizations or individuals.,Daftar beberapa Supplier Anda. Mereka bisa menjadi organisasi atau individu.
apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Lihat Semua Produk
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimum Umur Prospek (Hari)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +57,All BOMs,semua BOMs
DocType: Patient,Default Currency,Standar Mata Uang
DocType: Expense Claim,From Employee,Dari Karyawan
DocType: Driver,Cellphone Number,Nomor ponsel
apps/erpnext/erpnext/controllers/accounts_controller.py +471,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Peringatan: Sistem tidak akan memeriksa overbilling karena jumlahnya untuk Item {0} pada {1} adalah nol
DocType: Journal Entry,Make Difference Entry,Buat Entri Perbedaan
DocType: Upload Attendance,Attendance From Date,Absensi Kehadiran dari Tanggal
DocType: Appraisal Template Goal,Key Performance Area,Area Kinerja Kunci
DocType: Program Enrollment,Transportation,Transportasi
apps/erpnext/erpnext/controllers/item_variant.py +92,Invalid Attribute,Atribut yang tidak valid
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +229,{0} {1} must be submitted,{0} {1} harus dikirim
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +151,Quantity must be less than or equal to {0},Kuantitas harus kurang dari atau sama dengan {0}
DocType: SMS Center,Total Characters,Jumlah Karakter
DocType: Employee Advance,Claimed,Diklaim
DocType: Crop,Row Spacing,Row Spacing
apps/erpnext/erpnext/controllers/buying_controller.py +164,Please select BOM in BOM field for Item {0},Silakan pilih BOM BOM di lapangan untuk Item {0}
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktur Detil
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Rekonsiliasi Faktur Pembayaran
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Kontribusi%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Sesuai dengan Setelan Pembelian jika Pesanan Pembelian Diperlukan == &#39;YA&#39;, maka untuk membuat Purchase Invoice, pengguna harus membuat Purchase Order terlebih dahulu untuk item {0}"
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Nomor registrasi perusahaan untuk referensi Anda. Nomor pajak dll
DocType: Sales Partner,Distributor,Distributor
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Aturan Pengiriman Belanja Shoping Cart
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Production Order {0} must be cancelled before cancelling this Sales Order,Order produksi {0} harus dibatalkan sebelum membatalkan Sales Order ini
apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Silahkan mengatur &#39;Terapkan Diskon tambahan On&#39;
,Ordered Items To Be Billed,Item Pesanan Tertagih
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Dari Rentang harus kurang dari Untuk Rentang
DocType: Global Defaults,Global Defaults,Standar Global
apps/erpnext/erpnext/projects/doctype/project/project.py +226,Project Collaboration Invitation,Proyek Kolaborasi Undangan
DocType: Salary Slip,Deductions,Pengurangan
DocType: Leave Allocation,LAL/,LAL /
DocType: Setup Progress Action,Action Name,Nama Aksi
apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Mulai Tahun
apps/erpnext/erpnext/regional/india/utils.py +25,First 2 digits of GSTIN should match with State number {0},2 digit pertama GSTIN harus sesuai dengan nomor Negara {0}
DocType: Purchase Invoice,Start date of current invoice's period,Tanggal faktur periode saat ini mulai
DocType: Salary Slip,Leave Without Pay,Cuti Tanpa Bayar
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,Kesalahan Perencanaan Kapasitas
,Trial Balance for Party,Trial Balance untuk Partai
DocType: Lead,Consultant,Konsultan
DocType: Salary Slip,Earnings,Pendapatan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +421,Finished Item {0} must be entered for Manufacture type entry,Selesai Stok Barang {0} harus dimasukkan untuk jenis Produksi entri
apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Saldo Pembukaan Akuntansi
,GST Sales Register,Daftar Penjualan GST
DocType: Sales Invoice Advance,Sales Invoice Advance,Uang Muka Faktur Penjualan
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,Tidak ada Permintaan
apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Pilih Domain Anda
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},record Anggaran lain &#39;{0}&#39; sudah ada terhadap {1} &#39;{2}&#39; untuk tahun fiskal {3}
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Fields akan disalin hanya pada saat penciptaan.
apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date','Tanggal Mulai Sebenarnya' tidak bisa lebih besar dari 'Tanggal Selesai Sebenarnya'
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Manajemen
DocType: Cheque Print Template,Payer Settings,Pengaturan Wajib
DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Ini akan ditambahkan ke Item Code dari varian. Sebagai contoh, jika Anda adalah singkatan ""SM"", dan kode Stok Barang adalah ""T-SHIRT"", kode item varian akan ""T-SHIRT-SM"""
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Pay Bersih (dalam kata-kata) akan terlihat setelah Anda menyimpan Slip Gaji.
DocType: Purchase Invoice,Is Return,Retur Barang
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +88,Caution,Peringatan
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,Return / Debit Note,Nota Retur / Debit
DocType: Price List Country,Price List Country,Negara Daftar Harga
DocType: Item,UOMs,UOMs
apps/erpnext/erpnext/stock/utils.py +209,{0} valid serial nos for Item {1},{0} nomor seri berlaku untuk Item {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Item Code tidak dapat diubah untuk Serial Number
DocType: Purchase Invoice Item,UOM Conversion Factor,Faktor Konversi UOM
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Masukkan Item Code untuk mendapatkan Nomor Batch
DocType: Stock Settings,Default Item Group,Standar Item Grup
DocType: Employee Loan,Partially Disbursed,sebagian Dicairkan
apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Berikan informasi.
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Database Supplier.
DocType: Account,Balance Sheet,Neraca
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +748,Cost Center For Item with Item Code ',Biaya Center For Stok Barang dengan Item Code '
DocType: Fee Validity,Valid Till,Berlaku sampai
apps/erpnext/erpnext/accounts/page/pos/pos.js +2474,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Modus pembayaran tidak dikonfigurasi. Silakan periksa, apakah akun telah ditetapkan pada Cara Pembayaran atau POS Profil."
apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,item yang sama tidak dapat dimasukkan beberapa kali.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups","Account lebih lanjut dapat dibuat di bawah Grup, tapi entri dapat dilakukan terhadap non-Grup"
DocType: Lead,Lead,Prospek
DocType: Email Digest,Payables,Hutang
DocType: Course,Course Intro,tentu saja Intro
apps/erpnext/erpnext/stock/doctype/batch/batch.js +97,Stock Entry {0} created,Entri Persediaan {0} dibuat
apps/erpnext/erpnext/controllers/buying_controller.py +316,Row #{0}: Rejected Qty can not be entered in Purchase Return,Baris # {0}: Jumlah yang ditolak tidak dapat dimasukkan dalam Retur Pembelian
,Purchase Order Items To Be Billed,Purchase Order Items Akan Ditagih
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Updating estimated arrival times.,Memperbarui perkiraan waktu kedatangan.
DocType: Program Enrollment Tool,Enrollment Details,Rincian pendaftaran
DocType: Purchase Invoice Item,Net Rate,Nilai Bersih / Net
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +147,Please select a customer,Silahkan pilih pelanggan
DocType: Purchase Invoice Item,Purchase Invoice Item,Stok Barang Faktur Pembelian
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Entri Buku Persediaan dan Entri GL diposting ulang untuk Nota Pembelian yang dipilih
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Item 1
DocType: Holiday,Holiday,Hari Libur
DocType: Support Settings,Close Issue After Days,Tutup Isu Setelah Days
DocType: Leave Control Panel,Leave blank if considered for all branches,Biarkan kosong jika dipertimbangkan untuk semua cabang
DocType: Bank Guarantee,Validity in Days,Validitas dalam hari
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-bentuk tidak berlaku untuk Faktur: {0}
DocType: Payment Reconciliation,Unreconciled Payment Details,Rincian Pembayaran Unreconciled
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Order Count
DocType: Global Defaults,Current Fiscal Year,Tahun Anggaran saat ini
DocType: Purchase Order,Group same items,Kelompok item yang sama
DocType: Purchase Invoice,Disable Rounded Total,Nonaktifkan Pembulatan Jumlah
DocType: Employee Loan Application,Repayment Info,Info pembayaran
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +446,'Entries' cannot be empty,'Entries' tidak boleh kosong
DocType: Maintenance Team Member,Maintenance Role,Peran Pemeliharaan
apps/erpnext/erpnext/utilities/transaction_base.py +86,Duplicate row {0} with same {1},Baris duplikat {0} dengan sama {1}
,Trial Balance,Trial Balance
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Tahun fiskal {0} tidak ditemukan
apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Persiapan Karyawan
DocType: Sales Order,SO-,BEGITU-
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,Silakan pilih awalan terlebih dahulu
DocType: Student,O-,HAI-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Penelitian
DocType: Maintenance Visit Purpose,Work Done,Pekerjaan Selesai
apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,Silakan tentukan setidaknya satu atribut dalam tabel Atribut
DocType: Announcement,All Students,Semua murid
apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Barang {0} harus barang non-persediaan
apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Lihat Buku Besar
DocType: Grading Scale,Intervals,interval
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Paling Awal
apps/erpnext/erpnext/stock/doctype/item/item.py +500,"An Item Group exists with same name, please change the item name or rename the item group","Item Grup ada dengan nama yang sama, ubah nama item atau mengubah nama kelompok Stok Barang"
DocType: Crop Cycle,Less than a year,Kurang dari setahun
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Mahasiswa Nomor Ponsel
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Rest of The World
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Item {0} tidak dapat memiliki Batch
DocType: Crop,Yield UOM,Hasil UOM
,Budget Variance Report,Laporan Perbedaan Anggaran
DocType: Salary Slip,Gross Pay,Nilai Gross Bayar
DocType: Item,Is Item from Hub,Adalah Item dari Hub
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Activity Type is mandatory.,Row {0}: Jenis Kegiatan adalah wajib.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Dividends Paid,Dividen Dibagi
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Buku Besar Akuntansi
DocType: Stock Reconciliation,Difference Amount,Jumlah Perbedaan
DocType: Purchase Invoice,Reverse Charge,Biaya terbalik
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Laba Ditahan
DocType: Vehicle Log,Service Detail,layanan Detil
DocType: BOM,Item Description,Deskripsi Barang
DocType: Student Sibling,Student Sibling,Mahasiswa Sibling
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18,Payment Mode,Mode Pembayaran
DocType: Purchase Invoice,Supplied Items,Produk Disupply
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Harap atur menu aktif untuk Restoran {0}
DocType: Student,STUD.,STUD.
DocType: Production Order,Qty To Manufacture,Kuantitas untuk diproduksi
DocType: Email Digest,New Income,Penghasilan baru
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Pertahankan tarif yang sama sepanjang siklus pembelian
DocType: Opportunity Item,Opportunity Item,Peluang Stok Barang
,Student and Guardian Contact Details,Mahasiswa dan Wali Detail Kontak
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +51,Row {0}: For supplier {0} Email Address is required to send email,Baris {0}: Untuk pemasok {0} Alamat Email diperlukan untuk mengirim email
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,Akun Pembukaan Sementara
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10,View Hub,Lihat Hub
,Employee Leave Balance,Nilai Cuti Karyawan
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Saldo Rekening {0} harus selalu {1}
DocType: Patient Appointment,More Info,Info Selengkapnya
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},Penilaian Tingkat diperlukan untuk Item berturut-turut {0}
DocType: Supplier Scorecard,Scorecard Actions,Tindakan Scorecard
apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Contoh: Magister Ilmu Komputer
DocType: Purchase Invoice,Rejected Warehouse,Gudang Reject
DocType: GL Entry,Against Voucher,Terhadap Voucher
DocType: Item,Default Buying Cost Center,Standar Biaya Pusat Pembelian
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Untuk mendapatkan yang terbaik dari ERPNext, kami menyarankan Anda mengambil beberapa waktu dan menonton video ini membantu."
apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,untuk
DocType: Supplier Quotation Item,Lead Time in days,Masa Tenggang dalam hari
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Ringkasan Buku Besar Hutang
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},Pembayaran gaji dari {0} ke {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Tidak berwenang untuk mengedit Akun frozen {0}
DocType: Journal Entry,Get Outstanding Invoices,Dapatkan Faktur Berjalan
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Order Penjualan {0} tidak valid
DocType: Supplier Scorecard,Warn for new Request for Quotations,Peringatkan untuk Permintaan Kuotasi baru
apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,pesanan pembelian membantu Anda merencanakan dan menindaklanjuti pembelian Anda
apps/erpnext/erpnext/setup/doctype/company/company.py +228,"Sorry, companies cannot be merged","Maaf, perusahaan tidak dapat digabungkan"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Resep Uji Lab
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +162,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Total Issue / transfer kuantitas {0} Material Permintaan {1} \ tidak dapat lebih besar dari yang diminta kuantitas {2} untuk Item {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,Kecil
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Membuka Item Alat Pembuatan Faktur
DocType: Education Settings,Employee Number,Jumlah Karyawan
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Kasus ada (s) sudah digunakan. Coba dari Case ada {0}
DocType: Project,% Completed,Selesai %
,Invoiced Amount (Exculsive Tax),Faktur Jumlah (Pajak exculsive)
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Item 2
DocType: Supplier,SUPP-,SUPP-
DocType: Training Event,Training Event,pelatihan Kegiatan
DocType: Item,Auto re-order,Auto re-order
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Total Dicapai
DocType: Employee,Place of Issue,Tempat Issue
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Kontrak
DocType: Plant Analysis,Laboratory Testing Datetime,Uji Laboratorium Datetime
DocType: Email Digest,Add Quote,Tambahkan Kutipan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +965,UOM coversion factor required for UOM: {0} in Item: {1},Faktor coversion UOM diperlukan untuk UOM: {0} di Item: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Biaya tidak langsung
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93,Row {0}: Qty is mandatory,Row {0}: Qty adalah wajib
DocType: Agriculture Analysis Criteria,Agriculture,Pertanian
apps/erpnext/erpnext/accounts/page/pos/pos.js +786,Sync Master Data,Sync Master Data
DocType: Asset Repair,Repair Cost,Biaya perbaikan
apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Produk atau Jasa Anda
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Gagal untuk masuk
DocType: Special Test Items,Special Test Items,Item Uji Khusus
DocType: Mode of Payment,Mode of Payment,Mode Pembayaran
apps/erpnext/erpnext/stock/doctype/item/item.py +192,Website Image should be a public file or website URL,Website Image harus file umum atau URL situs
DocType: Student Applicant,AP,AP
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Ini adalah kelompok Stok Barang akar dan tidak dapat diedit.
DocType: Journal Entry Account,Purchase Order,Purchase Order
DocType: Vehicle,Fuel UOM,BBM UOM
DocType: Warehouse,Warehouse Contact Info,Info Kontak Gudang
DocType: Payment Entry,Write Off Difference Amount,Menulis Off Perbedaan Jumlah
DocType: Volunteer,Volunteer Name,Nama Relawan
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: email Karyawan tidak ditemukan, maka email tidak dikirim"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Aturan pengiriman tidak berlaku untuk negara {0}
DocType: Item,Foreign Trade Details,Rincian Perdagangan Luar Negeri
,Assessment Plan Status,Status Rencana Penilaian
DocType: Email Digest,Annual Income,Pendapatan tahunan
DocType: Serial No,Serial No Details,Nomor Detail Serial
DocType: Purchase Invoice Item,Item Tax Rate,Tarif Pajak Stok Barang
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Silakan pilih Dokter dan Tanggal
DocType: Student Group Student,Group Roll Number,Nomor roll grup
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +143,"For {0}, only credit accounts can be linked against another debit entry","Untuk {0}, hanya rekening kredit dapat dihubungkan dengan entri debit lain"
apps/erpnext/erpnext/projects/doctype/project/project.py +80,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Total semua bobot tugas harus 1. Sesuaikan bobot dari semua tugas Proyek sesuai
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +575,Delivery Note {0} is not submitted,Nota pengiriman {0} tidak Terkirim
apps/erpnext/erpnext/stock/get_item_details.py +146,Item {0} must be a Sub-contracted Item,Item {0} harus Item Sub-kontrak
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Perlengkapan Modal
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Rule harga terlebih dahulu dipilih berdasarkan 'Terapkan On' lapangan, yang dapat Stok Barang, Stok Barang Grup atau Merek."
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +246,Please set the Item Code first,Harap set Kode Item terlebih dahulu
DocType: Item,ITEM-,BARANG-
apps/erpnext/erpnext/controllers/selling_controller.py +122,Total allocated percentage for sales team should be 100,Persentase total yang dialokasikan untuk tim penjualan harus 100
DocType: Sales Invoice Item,Edit Description,Edit Keterangan
DocType: Antibiotic,Antibiotic,Antibiotika
,Team Updates,Pembaruan Tim
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +910,For Supplier,Untuk Supplier
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Mengatur Tipe Akun membantu dalam memilih Akun ini dalam transaksi.
DocType: Purchase Invoice,Grand Total (Company Currency),Jumlah Nilai Total (Mata Uang Perusahaan)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Buat Print Format
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Biaya Dibuat
apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Tidak menemukan item yang disebut {0}
DocType: Supplier Scorecard Criteria,Criteria Formula,Formula Kriteria
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Total Outgoing
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Hanya ada satu Peraturan Pengiriman Kondisi dengan nilai kosong atau 0 untuk ""To Nilai"""
DocType: Authorization Rule,Transaction,Transaksi
DocType: Patient Appointment,Duration,Lamanya
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Catatan: Biaya Pusat ini adalah Group. Tidak bisa membuat entri akuntansi terhadap kelompok-kelompok.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,gudang anak ada untuk gudang ini. Anda tidak dapat menghapus gudang ini.
DocType: Item,Website Item Groups,Situs Grup Stok Barang
DocType: Purchase Invoice,Total (Company Currency),Total (Perusahaan Mata Uang)
apps/erpnext/erpnext/stock/utils.py +204,Serial number {0} entered more than once,Serial number {0} masuk lebih dari sekali
DocType: Journal Entry,Journal Entry,Jurnal Entri
DocType: Expense Claim Advance,Unclaimed amount,Jumlah yang tidak diklaim
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,{0} item berlangsung
DocType: Workstation,Workstation Name,Nama Workstation
DocType: Grading Scale Interval,Grade Code,Kode kelas
DocType: POS Item Group,POS Item Group,POS Barang Grup
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Surel Ringkasan:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +591,BOM {0} does not belong to Item {1},BOM {0} bukan milik Barang {1}
DocType: Sales Partner,Target Distribution,Target Distribusi
DocType: Salary Slip,Bank Account No.,No Rekening Bank
DocType: Naming Series,This is the number of the last created transaction with this prefix,Ini adalah jumlah transaksi yang diciptakan terakhir dengan awalan ini
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
","Variabel Scorecard dapat digunakan, dan juga: {total_score} (skor total dari periode tersebut), {period_number} (jumlah periode sampai sekarang)"
DocType: Quality Inspection Reading,Reading 8,Membaca 8
DocType: Sales Partner,Agent,Agen
DocType: Purchase Invoice,Taxes and Charges Calculation,Pajak dan Biaya Dihitung
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Rekam Depresiasi Asset Entri Otomatis
DocType: BOM Operation,Workstation,Workstation
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Permintaan Quotation Pemasok
DocType: Healthcare Settings,Registration Message,Pesan Pendaftaran
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Perangkat keras
DocType: Prescription Dosage,Prescription Dosage,Dosis Resep
DocType: Attendance,HR Manager,HR Manager
apps/erpnext/erpnext/accounts/party.py +178,Please select a Company,Silakan pilih sebuah Perusahaan
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Privilege Cuti
DocType: Purchase Invoice,Supplier Invoice Date,Tanggal Faktur Supplier
apps/erpnext/erpnext/templates/includes/product_page.js +18,per,per
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Anda harus mengaktifkan Keranjang Belanja
DocType: Payment Entry,Writeoff,writeoff
DocType: Stock Settings,Naming Series Prefix,Awalan Seri Penamaan
DocType: Appraisal Template Goal,Appraisal Template Goal,Template Target Penilaian Pencapaian
DocType: Salary Component,Earning,Pendapatan
DocType: Supplier Scorecard,Scoring Criteria,Kriteria penilaian
DocType: Purchase Invoice,Party Account Currency,Akun Mata Uang per Party
,BOM Browser,BOM Browser
apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Harap perbarui status anda untuk acara pelatihan ini
DocType: Purchase Taxes and Charges,Add or Deduct,Penambahan atau Pengurangan
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Kondisi Tumpang Tindih ditemukan antara:
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Atas Catatan Jurnal {0} sudah dilakukan penyesuaian terhadap beberapa dokumen lain.
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Nilai Total Order
apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,Makanan
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Rentang Ageing 3
DocType: Maintenance Schedule Item,No of Visits,Tidak ada Kunjungan
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Jadwal Pemeliharaan {0} ada terhadap {1}
apps/erpnext/erpnext/hub_node/page/hub/hub.js +118,Do you want to publish your Items to Hub ?,Ingin menerbitkan Item ke Hub?
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,mahasiswa Mendaftarkan
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Mata uang dari Rekening Penutupan harus {0}
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Jumlah poin untuk semua tujuan harus 100. Ini adalah {0}
DocType: Project,Start and End Dates,Mulai dan Akhir Tanggal
,Delivered Items To Be Billed,Produk Terkirim untuk Ditagih
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Terbuka BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Gudang tidak dapat diubah untuk Serial Number
DocType: Authorization Rule,Average Discount,Rata-rata Diskon
DocType: Purchase Invoice Item,UOM,UOM
DocType: Rename Tool,Utilities,Utilitas
DocType: POS Profile,Accounting,Akuntansi
DocType: Employee,EMP/,EMP /
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Silakan pilih batch untuk item batched
DocType: Asset,Depreciation Schedules,Jadwal penyusutan
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +159,Following accounts might be selected in GST Settings:,Akun berikut mungkin dipilih di Setelan GST:
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Periode aplikasi tidak bisa periode alokasi cuti di luar
DocType: Activity Cost,Projects,Proyek
DocType: Payment Request,Transaction Currency,Mata uang transaksi
apps/erpnext/erpnext/controllers/buying_controller.py +30,From {0} | {1} {2},Dari {0} | {1} {2}
DocType: Production Order Operation,Operation Description,Deskripsi Operasi
DocType: Item,Will also apply to variants,Juga akan berlaku untuk varian
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,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.
DocType: Quotation,Shopping Cart,Daftar Belanja
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Rata-rata Harian Outgoing
DocType: POS Profile,Campaign,Promosi
DocType: Supplier,Name and Type,Nama dan Jenis
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +66,Approval Status must be 'Approved' or 'Rejected',Status Persetujuan harus 'Disetujui' atau 'Ditolak'
DocType: Physician,Contacts and Address,Kontak dan Alamat
DocType: Purchase Invoice,Contact Person,Contact Person
apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date',"""Jadwal Tanggal Mulai' tidak dapat lebih besar dari 'Jadwal Tanggal Selesai'"
DocType: Course Scheduling Tool,Course End Date,Tentu saja Tanggal Akhir
DocType: Holiday List,Holidays,Hari Libur
DocType: Sales Order Item,Planned Quantity,Direncanakan Kuantitas
DocType: Purchase Invoice Item,Item Tax Amount,Jumlah Pajak Stok Barang
DocType: Water Analysis,Water Analysis Criteria,Kriteria Analisis Air
DocType: Item,Maintain Stock,Jaga Persediaan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +222,Stock Entries already created for Production Order ,Entri Persediaan sudah dibuat untuk Perintah Produksi
DocType: Employee,Prefered Email,Email Utama
DocType: Student Admission,Eligibility and Details,Kelayakan dan Detail
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Perubahan bersih dalam Aset Tetap
DocType: Leave Control Panel,Leave blank if considered for all designations,Biarkan kosong jika dipertimbangkan untuk semua sebutan
apps/erpnext/erpnext/controllers/accounts_controller.py +799,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Mengisi tipe 'sebenarnya' berturut-turut {0} tidak dapat dimasukkan dalam Butir Tingkat
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +382,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Dari Datetime
DocType: Email Digest,For Company,Untuk Perusahaan
apps/erpnext/erpnext/config/support.py +17,Communication log.,Log komunikasi.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +193,"Request for Quotation is disabled to access from portal, for more check portal settings.","Permintaan Quotation dinonaktifkan untuk akses dari portal, untuk pengaturan Portal cek lagi."
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Variabel Scorecard Supplier Variabel
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Jumlah Pembelian
DocType: Sales Invoice,Shipping Address Name,Alamat Pengiriman
DocType: Material Request,Terms and Conditions Content,Syarat dan Ketentuan Konten
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Ada kesalahan dalam membuat Jadwal Kursus
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +580,cannot be greater than 100,tidak dapat lebih besar dari 100
apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item {0} is not a stock Item,Barang {0} bukan merupakan Barang persediaan
DocType: Maintenance Visit,Unscheduled,Tidak Terjadwal
DocType: Employee,Owned,Dimiliki
DocType: Salary Detail,Depends on Leave Without Pay,Tergantung pada Cuti Tanpa Bayar
DocType: Pricing Rule,"Higher the number, higher the priority","Semakin tinggi angkanya, semakin tinggi prioritas"
,Purchase Invoice Trends,Pembelian Faktur Trends
DocType: Employee,Better Prospects,Prospek yang Lebih Baik
apps/erpnext/erpnext/stock/doctype/batch/batch.py +139,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Baris # {0}: Kumpulan {1} hanya memiliki {2} qty. Silakan pilih batch lain yang memiliki {3} qty available atau membagi baris menjadi beberapa baris, untuk mengirimkan / mengeluarkan dari beberapa batch"
DocType: Vehicle,License Plate,Pelat
DocType: Appraisal,Goals,tujuan
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +343,Select POS Profile,Pilih Profil POS
DocType: Warranty Claim,Warranty / AMC Status,Garansi / Status AMC
,Accounts Browser,Browser Nama Akun
DocType: Payment Entry Reference,Payment Entry Reference,Pembayaran Referensi Masuk
DocType: GL Entry,GL Entry,GL Entri
DocType: HR Settings,Employee Settings,Pengaturan Karyawan
,Batch-Wise Balance History,Rekap Saldo menurut Kumpulan
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Pengaturan cetak diperbarui dalam format cetak terkait
DocType: Package Code,Package Code,Kode paket
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,Magang
DocType: Purchase Invoice,Company GSTIN,Perusahaan GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,Negative Quantity is not allowed,Jumlah negatif tidak diperbolehkan
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Rinci tabel pajak diambil dari master Stok Barang sebagai string dan disimpan dalam bidang ini.
 Digunakan untuk Pajak dan Biaya"
DocType: Supplier Scorecard Period,SSC-,SSC-
apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,Karyawan tidak bisa melaporkan kepada dirinya sendiri.
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Jika account beku, entri yang diizinkan untuk pengguna terbatas."
DocType: Email Digest,Bank Balance,Saldo bank
apps/erpnext/erpnext/accounts/party.py +243,Accounting Entry for {0}: {1} can only be made in currency: {2},Entri Akuntansi untuk {0}: {1} hanya dapat dilakukan dalam mata uang: {2}
DocType: Job Opening,"Job profile, qualifications required etc.","Profil pekerjaan, kualifikasi yang dibutuhkan dll"
DocType: Journal Entry Account,Account Balance,Saldo Akun Rekening
apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Aturan pajak untuk transaksi.
DocType: Rename Tool,Type of document to rename.,Jenis dokumen untuk mengubah nama.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Pelanggan diperlukan untuk akun Piutang {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Jumlah Pajak dan Biaya (Perusahaan Mata Uang)
apps/erpnext/erpnext/config/healthcare.py +154,Lab Test Template.,Lab Test Template.
DocType: Weather,Weather Parameter,Parameter Cuaca
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Tampilkan P &amp; saldo L tahun fiskal tertutup ini
DocType: Lab Test Template,Collection Details,Detail Koleksi
DocType: POS Profile,Allow Print Before Pay,Izinkan Cetak Sebelum Bayar
DocType: Land Unit,Linked Soil Texture,Tekstur Tanah Tertib
DocType: Shipping Rule,Shipping Account,Account Pengiriman
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Akun {2} tidak aktif
apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Membuat Penjualan Pesanan untuk membantu Anda merencanakan pekerjaan Anda dan memberikan tepat waktu
DocType: Quality Inspection,Readings,Bacaan
DocType: Stock Entry,Total Additional Costs,Total Biaya Tambahan
DocType: Course Schedule,SH,SH
DocType: BOM,Scrap Material Cost(Company Currency),Scrap Material Cost (Perusahaan Mata Uang)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Sub Assemblies
DocType: Asset,Asset Name,Aset Nama
DocType: Project,Task Weight,tugas Berat
DocType: Shipping Rule Condition,To Value,Untuk Dinilai
DocType: Asset Movement,Stock Manager,Pengelola Persediaan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +154,Source warehouse is mandatory for row {0},Sumber gudang adalah wajib untuk baris {0}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Syarat Pembayaran di baris {0} mungkin merupakan duplikat.
apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Pertanian (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +856,Packing Slip,Slip Packing
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Sewa Kantor
apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Pengaturan gerbang Pengaturan SMS
DocType: Disease,Common Name,Nama yang umum
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Impor Gagal!
apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Belum ditambahkan alamat
DocType: Workstation Working Hour,Workstation Working Hour,Jam Kerja Workstation
DocType: Vital Signs,Blood Pressure,Tekanan darah
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,Analis
DocType: Item,Inventory,Inventarisasi
DocType: Item,Sales Details,Detail Penjualan
DocType: Quality Inspection,QI-,QI-
DocType: Opportunity,With Items,Dengan Produk
DocType: Asset Maintenance,Maintenance Team,Tim Pemeliharaan
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,Dalam Qty
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Validasi Kursus Terdaftar untuk Siswa di Kelompok Pelajar
DocType: Notification Control,Expense Claim Rejected,Beban Klaim Ditolak
DocType: Item,Item Attribute,Item Atribut
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,pemerintahan
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Beban Klaim {0} sudah ada untuk Kendaraan Log
apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,nama institusi
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Masukkan pembayaran Jumlah
apps/erpnext/erpnext/config/stock.py +305,Item Variants,Item Varian
apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Jasa
DocType: HR Settings,Email Salary Slip to Employee,Email Slip Gaji ke Karyawan
DocType: Cost Center,Parent Cost Center,Parent Biaya Pusat
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1039,Select Possible Supplier,Pilih Kemungkinan Pemasok
DocType: Sales Invoice,Source,Sumber
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Tampilkan ditutup
DocType: Leave Type,Is Leave Without Pay,Apakah Cuti Tanpa Bayar
apps/erpnext/erpnext/stock/doctype/item/item.py +250,Asset Category is mandatory for Fixed Asset item,Aset Kategori adalah wajib untuk item aset tetap
DocType: Fee Validity,Fee Validity,Validitas biaya
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,No records found in the Payment table,Tidak ada catatan yang ditemukan dalam tabel Pembayaran
apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Ini {0} konflik dengan {1} untuk {2} {3}
DocType: Student Attendance Tool,Students HTML,siswa HTML
DocType: POS Profile,Apply Discount,Terapkan Diskon
DocType: GST HSN Code,GST HSN Code,Kode HSN GST
DocType: Employee External Work History,Total Experience,Jumlah Pengalaman
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,terbuka Proyek
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +286,Packing Slip(s) cancelled,Packing slip (s) dibatalkan
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +31,Cash Flow from Investing,Arus Kas dari Investasi
DocType: Program Course,Program Course,Kursus Program
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Pengangkutan dan Forwarding Biaya
DocType: Homepage,Company Tagline for website homepage,Perusahaan Tagline untuk homepage website
DocType: Item Group,Item Group Name,Nama Item Grup
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Diambil
DocType: Student,Date of Leaving,Tanggal Meninggalkan
DocType: Pricing Rule,For Price List,Untuk Daftar Harga
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Pencarian eksekutif
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Pengaturan default
apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Buat Prospek
DocType: Maintenance Schedule,Schedules,Jadwal
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +458,POS Profile is required to use Point-of-Sale,Profil POS diharuskan menggunakan Point of Sale
DocType: Purchase Invoice Item,Net Amount,Nilai Bersih
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +138,{0} {1} has not been submitted so the action cannot be completed,{0} {1} belum dikirim sehingga tindakan tidak dapat diselesaikan
DocType: Purchase Order Item Supplied,BOM Detail No,No. Rincian BOM
DocType: Landed Cost Voucher,Additional Charges,Pungutan-pungutan tambahan
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Jumlah Diskon Tambahan (dalam Mata Uang Perusahaan)
DocType: Supplier Scorecard,Supplier Scorecard,Supplier Scorecard
DocType: Plant Analysis,Result Datetime,Hasil Datetime
apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Silahkan buat akun baru dari Bagan Akun.
,Support Hour Distribution,Distribusi Jam Dukungan
DocType: Maintenance Visit,Maintenance Visit,Kunjungan Pemeliharaan
DocType: Student,Leaving Certificate Number,Meninggalkan Sertifikat Nomor
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +63,"Appointment cancelled, Please review and cancel the invoice {0}","Penunjukan dibatalkan, Harap tinjau dan batalkan faktur {0}"
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Tersedia Batch Qty di Gudang
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Perbarui Format Cetak
DocType: Landed Cost Voucher,Landed Cost Help,Bantuan Biaya Landed
DocType: Purchase Invoice,Select Shipping Address,Pilih Alamat Pengiriman
apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Rincian Memebership
DocType: Leave Block List,Block Holidays on important days.,Blok Hari Libur pada hari-hari penting.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Ringkasan Buku Piutang
DocType: Employee Loan,Monthly Repayment Amount,Bulanan Pembayaran Jumlah
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Membuka Faktur
apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,Please set User ID field in an Employee record to set Employee Role,Silakan set ID lapangan Pengguna dalam catatan Karyawan untuk mengatur Peran Karyawan
DocType: UOM,UOM Name,Nama UOM
DocType: GST HSN Code,HSN Code,Kode HSN
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Jumlah kontribusi
DocType: Purchase Invoice,Shipping Address,Alamat Pengiriman
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Alat ini membantu Anda memperbarui atau memperbaiki kuantitas dan valuasi persediaan di sistem. Biasanya digunakan untuk menyelaraskan sistem dengan aktual barang yang ada di gudang.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,Dalam Kata-kata akan terlihat sekali Anda menyimpan Delivery Note.
DocType: Expense Claim,EXP,EXP
DocType: Water Analysis,Container,Wadah
apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Mahasiswa {0} - {1} muncul Beberapa kali berturut-turut {2} &amp; {3}
DocType: Healthcare Settings,Manage Sample Collection,Mengelola Sampel Koleksi
DocType: Patient,Tobacco Past Use,Tobacco Past Use
DocType: Sales Invoice Item,Brand Name,Nama Merek
DocType: Purchase Receipt,Transporter Details,Detail transporter
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Pengguna {0} sudah ditugaskan ke Dokter {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2658,Default warehouse is required for selected item,gudang standar diperlukan untuk item yang dipilih
apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Kotak
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1036,Possible Supplier,mungkin Pemasok
DocType: Budget,Monthly Distribution,Distribusi bulanan
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Receiver List kosong. Silakan membuat Receiver List
apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Kesehatan (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Rencana Produksi berdasar Order Penjualan
DocType: Sales Partner,Sales Partner Target,Sasaran Mitra Penjualan
DocType: Loan Type,Maximum Loan Amount,Maksimum Jumlah Pinjaman
DocType: Pricing Rule,Pricing Rule,Aturan Harga
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Nomor pengguliran duplikat untuk siswa {0}
DocType: Budget,Action if Annual Budget Exceeded,Tindakan jika Anggaran Tahunan Melebihi
apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Permintaan Material untuk Order Pembelian
DocType: Shopping Cart Settings,Payment Success URL,Pembayaran Sukses URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +80,Row # {0}: Returned Item {1} does not exists in {2} {3},Baris # {0}: Barang Retur {1} tidak ada dalam {2} {3}
DocType: Purchase Receipt,PREC-,PREC-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Rekening Bank
,Bank Reconciliation Statement,Laporan Rekonsiliasi Bank
DocType: Consultation,Medical Coding,Pengkodean medis
DocType: Healthcare Settings,Reminder Message,Pesan pengingat
,Lead Name,Nama Prospek
,POS,POS
DocType: C-Form,III,AKU AKU AKU
apps/erpnext/erpnext/config/stock.py +310,Opening Stock Balance,Saldo Persediaan Pembukaan
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} harus muncul hanya sekali
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},cuti Dialokasikan Berhasil untuk {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Tidak ada item untuk dikemas
DocType: Shipping Rule Condition,From Value,Dari Nilai
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586,Manufacturing Quantity is mandatory,Qty Manufaktur  wajib diisi
DocType: Employee Loan,Repayment Method,Metode pembayaran
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Jika diperiksa, Home page akan menjadi default Barang Group untuk website"
DocType: Quality Inspection Reading,Reading 4,Membaca 4
apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Klaim untuk biaya perusahaan.
apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Siswa di jantung dari sistem, menambahkan semua siswa Anda"
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: tanggal Jarak {1} tidak bisa sebelum Cek Tanggal {2}
DocType: Asset Maintenance Task,Certificate Required,Sertifikat yang dibutuhkan
DocType: Company,Default Holiday List,Standar Daftar Hari Libur
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,Row {0}: From Time and To Time of {1} is overlapping with {2},Row {0}: Dari Waktu dan Untuk Waktu {1} adalah tumpang tindih dengan {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Hutang Persediaan
DocType: Purchase Invoice,Supplier Warehouse,Gudang Supplier
DocType: Opportunity,Contact Mobile No,Kontak Mobile No
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +389,Select Company,Pilih Perusahaan
,Material Requests for which Supplier Quotations are not created,Permintaan Material yang Supplier Quotation tidak diciptakan
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Pengguna {0} tidak memiliki Profil POS default. Cek Default di Baris {1} untuk Pengguna ini.
DocType: Student Group,Set 0 for no limit,Set 0 untuk tidak ada batas
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +141,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Hari (s) yang Anda lamar cuti adalah hari libur. Anda tidak perlu mengajukan cuti.
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Baris {idx}: {field} diperlukan untuk membuat Pembukaan {invoice_type} Faktur
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Kirim ulang Email Pembayaran
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,tugas baru
DocType: Consultation,Appointment,Janji
apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Membuat Quotation
apps/erpnext/erpnext/config/selling.py +216,Other Reports,Laporan lainnya
apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Pilih setidaknya satu domain.
DocType: Dependent Task,Dependent Task,Tugas Dependent
apps/erpnext/erpnext/stock/doctype/item/item.py +430,Conversion factor for default Unit of Measure must be 1 in row {0},Faktor konversi untuk Unit default Ukur harus 1 berturut-turut {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +208,Leave of type {0} cannot be longer than {1},Cuti jenis {0} tidak boleh lebih dari {1}
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Coba operasi untuk hari X perencanaan di muka.
DocType: HR Settings,Stop Birthday Reminders,Stop Pengingat Ulang Tahun
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Silahkan mengatur default Payroll Hutang Akun di Perusahaan {0}
DocType: SMS Center,Receiver List,Daftar Penerima
apps/erpnext/erpnext/accounts/page/pos/pos.js +1084,Search Item,Cari Barang
DocType: Payment Schedule,Payment Amount,Jumlah pembayaran
DocType: Patient Appointment,Referring Physician,Merujuk Dokter
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Dikonsumsi Jumlah
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Perubahan bersih dalam kas
DocType: Assessment Plan,Grading Scale,Skala penilaian
apps/erpnext/erpnext/stock/doctype/item/item.py +425,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Satuan Ukur {0} telah dimasukkan lebih dari sekali dalam Faktor Konversi Tabel
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +617,Already completed,Sudah lengkap
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Persediaan Di Tangan
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Impor Sukses!
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Permintaan pembayaran sudah ada {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Biaya Produk Dikeluarkan
DocType: Physician,Hospital,RSUD
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +385,Quantity must not be more than {0},Kuantitas tidak boleh lebih dari {0}
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Sebelumnya Keuangan Tahun tidak tertutup
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Umur (Hari)
DocType: Quotation Item,Quotation Item,Produk/Barang Penawaran
DocType: Customer,Customer POS Id,Id POS Pelanggan
DocType: Account,Account Name,Nama Akun
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Dari Tanggal tidak dapat lebih besar dari To Date
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serial ada {0} kuantitas {1} tak bisa menjadi pecahan
apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Supplier Type induk.
DocType: Purchase Order Item,Supplier Part Number,Supplier Part Number
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Tingkat konversi tidak bisa 0 atau 1
DocType: Subscription,Reference Document,Dokumen referensi
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +209,{0} {1} is cancelled or stopped,{0} {1} dibatalkan atau dihentikan
DocType: Accounts Settings,Credit Controller,Kredit Kontroller
DocType: Grant Application,Applicant Type,Jenis Pemohon
DocType: Delivery Note,Vehicle Dispatch Date,Kendaraan Dikirim Tanggal
DocType: Healthcare Settings,Default Medical Code Standard,Standar Kode Standar Medis
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,Nota Penerimaan {0} tidak Terkirim
DocType: Company,Default Payable Account,Standar Akun Hutang
apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Pengaturan untuk keranjang belanja online seperti aturan pengiriman, daftar harga dll"
apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% Ditagih
apps/erpnext/erpnext/hub_node/page/hub/hub.js +179,Sort by Price ...,Urutkan menurut Harga ...
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Reserved Qty
DocType: Party Account,Party Account,Akun Party
apps/erpnext/erpnext/config/setup.py +122,Human Resources,Sumber Daya Manusia
DocType: Lead,Upper Income,Penghasilan Atas
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,Menolak
DocType: Journal Entry Account,Debit in Company Currency,Debit di Mata Uang Perusahaan
DocType: BOM Item,BOM Item,Komponen BOM
DocType: Appraisal,For Employee,Untuk Karyawan
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Membuat Pencairan Masuk
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Supplier must be debit,Row {0}: Muka melawan Supplier harus mendebet
DocType: Company,Default Values,Nilai Default
DocType: Membership,INR,INR
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Frekuensi} Digest
DocType: Expense Claim,Total Amount Reimbursed,Jumlah Total diganti
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Hal ini didasarkan pada log terhadap kendaraan ini. Lihat timeline di bawah untuk rincian
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Terhadap Faktur Supplier {0} di tanggal {1}
DocType: Customer,Default Price List,Standar List Harga
apps/erpnext/erpnext/assets/doctype/asset/asset.py +269,Asset Movement record {0} created,Gerakan aset catatan {0} dibuat
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Anda tidak dapat menghapus Tahun Anggaran {0}. Tahun Fiskal {0} diatur sebagai default di Pengaturan Global
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Pelanggan dengan nama yang sama sudah ada
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +183,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Ini akan mengirimkan Slip Gaji dan membuat Entri Jurnal akrual. Apakah kamu ingin melanjutkan?
DocType: Purchase Invoice,Total Net Weight,Total Berat Bersih
DocType: Journal Entry,Entry Type,Entri Type
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Tidak ada rencana penilaian yang terkait dengan kelompok penilaian ini
,Customer Credit Balance,Saldo Kredit Pelanggan
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Perubahan bersih Hutang
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Pelanggan diperlukan untuk 'Diskon Pelanggan'
apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Perbarui tanggal pembayaran bank dengan jurnal.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,harga
DocType: Quotation,Term Details,Rincian Term
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,tidak bisa mendaftar lebih dari {0} siswa untuk kelompok siswa ini.
apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),Total (Tanpa Pajak)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Jumlah Prospek
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} harus lebih besar dari 0
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30,Stock Available,Stok Tersedia
DocType: Manufacturing Settings,Capacity Planning For (Days),Perencanaan Kapasitas Untuk (Hari)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Pembelian
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66,None of the items have any change in quantity or value.,Tak satu pun dari item memiliki perubahan kuantitas atau nilai.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Bidang wajib - Program
DocType: Special Test Template,Result Component,Komponen Hasil
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garansi Klaim
,Lead Details,Rincian Prospek
DocType: Volunteer,Availability and Skills,Ketersediaan dan Keterampilan
DocType: Salary Slip,Loan repayment,Pembayaran pinjaman
DocType: Purchase Invoice,End date of current invoice's period,Tanggal akhir periode faktur saat ini
DocType: Pricing Rule,Applicable For,Berlaku Untuk
DocType: Lab Test,Technician Name,Nama teknisi
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Membatalkan tautan Pembayaran pada Pembatalan Faktur
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Odometer membaca saat masuk harus lebih besar dari awal Kendaraan Odometer {0}
DocType: Restaurant Reservation,No Show,Tidak menunjukkan
DocType: Shipping Rule Country,Shipping Rule Country,Aturan Pengiriman – Negara
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Tinggalkan dan Kehadiran
DocType: Maintenance Visit,Partially Completed,Selesai Sebagian
apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Sensitivitas sedang
DocType: Leave Type,Include holidays within leaves as leaves,Sertakan libur dalam cuti cuti
DocType: Sales Invoice,Packed Items,Produk Kemasan
apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garansi Klaim terhadap Serial No.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +71,'Total',&#39;Total&#39;
DocType: Shopping Cart Settings,Enable Shopping Cart,Aktifkan Keranjang Belanja
DocType: Employee,Permanent Address,Alamat Tetap
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +258,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Uang muka yang dibayar terhadap {0} {1} tidak dapat lebih besar \ dari Grand Total {2}
DocType: Patient,Medication,Obat
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Silahkan pilih kode Stok Barang
DocType: Student Sibling,Studying in Same Institute,Belajar di Same Institute
DocType: Territory,Territory Manager,Manager Wilayah
DocType: Packed Item,To Warehouse (Optional),Untuk Gudang (pilihan)
DocType: GST Settings,GST Accounts,Akun GST
DocType: Payment Entry,Paid Amount (Company Currency),Dibayar Jumlah (Perusahaan Mata Uang)
DocType: Purchase Invoice,Additional Discount,Potongan Tambahan
DocType: Selling Settings,Selling Settings,Pengaturan Penjualan
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Konfirmasi Tindakan
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Lelang Online
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,Please specify either Quantity or Valuation Rate or both,Silakan tentukan baik Quantity atau Tingkat Penilaian atau keduanya
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,Pemenuhan
apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Lihat Troli
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Beban Pemasaran
,Item Shortage Report,Laporan Kekurangan Barang / Item
apps/erpnext/erpnext/stock/doctype/item/item.js +275,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Berat disebutkan, \n Sebutkan ""Berat UOM"" terlalu"
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Permintaan Material yang digunakan untuk membuat Entri Persediaan ini
apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Berikutnya Penyusutan Tanggal wajib untuk aset baru
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Kelompok terpisah berdasarkan Kelompok untuk setiap Batch
apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Unit tunggal Item.
DocType: Fee Category,Fee Category,biaya Kategori
DocType: Agriculture Task,Next Business Day,Hari bisnis selanjutnya
DocType: Customer,Primary Contact Detail,Detail Kontak Utama
DocType: Drug Prescription,Dosage by time interval,Dosis berdasarkan interval waktu
,Student Fee Collection,Mahasiswa Koleksi Fee
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Durasi Penunjukan (menit)
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Membuat Entri Akuntansi Untuk Setiap Perpindahan Persediaan
DocType: Leave Allocation,Total Leaves Allocated,Jumlah cuti Dialokasikan
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Gudang diperlukan pada Row nomor {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +142,Please enter valid Financial Year Start and End Dates,Entrikan Tahun Mulai berlaku Keuangan dan Tanggal Akhir
DocType: Employee,Date Of Retirement,Tanggal Pensiun
DocType: Upload Attendance,Get Template,Dapatkan Template
DocType: Material Request,Transferred,Ditransfer
DocType: Vehicle,Doors,pintu
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,ERPNext Pengaturan Selesai!
DocType: Healthcare Settings,Collect Fee for Patient Registration,Kumpulkan Biaya untuk Registrasi Pasien
apps/erpnext/erpnext/stock/doctype/item/item.py +650,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Tidak dapat mengubah Atribut setelah transaksi saham. Buat Item baru dan transfer saham ke Item baru
DocType: Course Assessment Criteria,Weightage,Weightage
DocType: Purchase Invoice,Tax Breakup,Perpisahan pajak
DocType: Packing Slip,PS-,PS
DocType: Member,Non Profit Member,Anggota nirlaba
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Pusat Biaya diperlukan untuk akun 'Rugi Laba' {2}. Silakan membuat Pusat Biaya default untuk Perusahaan.
DocType: Payment Schedule,Payment Term,Jangka waktu pembayaran
apps/erpnext/erpnext/selling/doctype/customer/customer.py +146,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Sudah ada Kelompok Pelanggan dengan nama yang sama, silakan ganti Nama Pelanggan atau ubah nama Kelompok Pelanggan"
DocType: Land Unit,Area,Daerah
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Kontak baru
DocType: Territory,Parent Territory,Wilayah Induk
DocType: Sales Invoice,Place of Supply,Tempat Pasokan
DocType: Quality Inspection Reading,Reading 2,Membaca 2
DocType: Stock Entry,Material Receipt,Nota Penerimaan Barang
DocType: Homepage,Products,Produk
DocType: Announcement,Instructor,Pengajar
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Pilih Item (opsional)
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Jadwal Biaya Kelompok Pelajar
DocType: Student,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Jika item ini memiliki varian, maka tidak dapat dipilih dalam order penjualan dll"
DocType: Lead,Next Contact By,Kontak Selanjutnya Oleh
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +314,Quantity required for Item {0} in row {1},Kuantitas yang dibutuhkan untuk Item {0} di baris {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},Gudang {0} tidak dapat dihapus karena ada kuantitas untuk Item {1}
DocType: Quotation,Order Type,Tipe Order
,Item-wise Sales Register,Item-wise Daftar Penjualan
DocType: Asset,Gross Purchase Amount,Jumlah Pembelian Gross
apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Saldo awal
DocType: Asset,Depreciation Method,Metode penyusutan
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Apakah Pajak ini termasuk dalam Basic Rate?
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Total Jumlah Target
DocType: Soil Texture,Sand Composition (%),Komposisi Pasir (%)
DocType: Job Applicant,Applicant for a Job,Pemohon untuk Lowongan Kerja
DocType: Production Plan Material Request,Production Plan Material Request,Produksi Permintaan Rencana Material
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Tidak ada Order Produksi dibuat
DocType: Stock Reconciliation,Reconciliation JSON,Rekonsiliasi JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Terlalu banyak kolom. Mengekspor laporan dan mencetaknya menggunakan aplikasi spreadsheet.
DocType: Purchase Invoice Item,Batch No,No. Batch
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Memungkinkan beberapa Order Penjualan terhadap Order Pembelian dari Pelanggan
DocType: Student Group Instructor,Student Group Instructor,Instruktur Kelompok Mahasiswa
DocType: Grant Application,Assessment  Mark (Out of 10),Tanda Penilaian (Dari 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Ponsel Tidak
apps/erpnext/erpnext/setup/doctype/company/company.py +207,Main,Utama
apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Varian
DocType: Naming Series,Set prefix for numbering series on your transactions,Mengatur awalan untuk penomoran seri pada transaksi Anda
DocType: Employee Attendance Tool,Employees HTML,Karyawan HTML
apps/erpnext/erpnext/stock/doctype/item/item.py +444,Default BOM ({0}) must be active for this item or its template,Standar BOM ({0}) harus aktif untuk item ini atau template-nya
DocType: Employee,Leave Encashed?,Cuti dicairkan?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Peluang Dari Bidang Usaha Wajib Diisi
DocType: Email Digest,Annual Expenses,Beban tahunan
DocType: Item,Variants,Varian
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1137,Make Purchase Order,Buat Order Pembelian
DocType: SMS Center,Send To,Kirim Ke
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},Tidak ada saldo cuti cukup bagi Leave Type {0}
DocType: Payment Reconciliation Payment,Allocated amount,Jumlah yang dialokasikan
DocType: Sales Team,Contribution to Net Total,Kontribusi terhadap Net Jumlah
DocType: Sales Invoice Item,Customer's Item Code,Kode Barang Pelanggan
DocType: Stock Reconciliation,Stock Reconciliation,Rekonsiliasi Persediaan
DocType: Territory,Territory Name,Nama Wilayah
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,Kerja-in-Progress Gudang diperlukan sebelum Submit
apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Pemohon untuk Lowongan Pekerjaan
DocType: Purchase Order Item,Warehouse and Reference,Gudang dan Referensi
DocType: Supplier,Statutory info and other general information about your Supplier,Info Statutory dan informasi umum lainnya tentang Supplier Anda
DocType: Item,Serial Nos and Batches,Nomor Seri dan Partai
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Kekuatan Kelompok Mahasiswa
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +250,Against Journal Entry {0} does not have any unmatched {1} entry,Catatan Jurnal {0} tidak memiliki {1} catatan yang belum dicocokan.
apps/erpnext/erpnext/config/hr.py +142,Appraisals,Penilaian
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Acara Pelatihan
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Gandakan Serial ada dimasukkan untuk Item {0}
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Sebuah kondisi untuk Aturan Pengiriman
apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,masukkan
apps/erpnext/erpnext/controllers/accounts_controller.py +487,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Tidak bisa overbill untuk Item {0} berturut-turut {1} lebih dari {2}. Untuk memungkinkan over-billing, silakan diatur dalam Membeli Pengaturan"
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Log Pemeliharaan
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +234,Please set filter based on Item or Warehouse,Silahkan mengatur filter berdasarkan Barang atau Gudang
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Berat bersih package ini. (Dihitung secara otomatis sebagai jumlah berat bersih item)
DocType: Sales Order,To Deliver and Bill,Untuk Dikirim dan Ditagih
DocType: Student Group,Instructors,instruktur
DocType: GL Entry,Credit Amount in Account Currency,Jumlah kredit di Akun Mata Uang
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +588,BOM {0} must be submitted,BOM {0} harus dikirimkan
DocType: Authorization Control,Authorization Control,Pengendali Otorisasi
apps/erpnext/erpnext/controllers/buying_controller.py +327,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Ditolak Gudang adalah wajib terhadap ditolak Stok Barang {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Payment,Pembayaran
apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Gudang {0} tidak ditautkan ke akun apa pun, sebutkan akun di catatan gudang atau tetapkan akun persediaan baku di perusahaan {1}."
apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Mengelola pesanan Anda
DocType: Production Order Operation,Actual Time and Cost,Waktu dan Biaya Aktual
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +54,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Permintaan Bahan maksimal {0} dapat dibuat untuk Item {1} terhadap Sales Order {2}
DocType: Crop,Crop Spacing,Jarak tanam
DocType: Course,Course Abbreviation,Singkatan saja
DocType: Student Leave Application,Student Leave Application,Mahasiswa Cuti Aplikasi
DocType: Item,Will also apply for variants,Juga akan berlaku untuk varian
apps/erpnext/erpnext/assets/doctype/asset/asset.py +164,"Asset cannot be cancelled, as it is already {0}","Aset tidak dapat dibatalkan, karena sudah {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Karyawan {0} tentang Half hari {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Jumlah jam kerja tidak boleh lebih besar dari max jam kerja {0}
apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Nyala
apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Bundel item pada saat penjualan.
DocType: Quotation Item,Actual Qty,Jumlah Aktual
DocType: Sales Invoice Item,References,Referensi
DocType: Quality Inspection Reading,Reading 10,Membaca 10
DocType: Hub Category,Hub Node,Hub Node
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Anda telah memasukan item duplikat. Harap perbaiki dan coba lagi.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Rekan
DocType: Asset Movement,Asset Movement,Gerakan aset
apps/erpnext/erpnext/accounts/page/pos/pos.js +2181,New Cart,Cart baru
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Item {0} bukan merupakan Stok Barang serial
DocType: SMS Center,Create Receiver List,Buat Daftar Penerima
DocType: Vehicle,Wheels,roda
DocType: Packing Slip,To Package No.,Untuk Paket No
DocType: Patient Relation,Family,Keluarga
DocType: Production Planning Tool,Material Requests,Permintaan bahan
DocType: Warranty Claim,Issue Date,Tanggal dibuat
DocType: Activity Cost,Activity Cost,Biaya Aktivitas
DocType: Sales Invoice Timesheet,Timesheet Detail,Detil absen
DocType: Purchase Receipt Item Supplied,Consumed Qty,Qty Dikonsumsi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekomunikasi
apps/erpnext/erpnext/accounts/party.py +266,Billing currency must be equal to either default company's currency or party account currency,Mata uang penagihan harus sama dengan mata uang perusahaan atau mata uang akun tertagih
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Menunjukkan bahwa paket tersebut merupakan bagian dari pengiriman ini (Hanya Draft)
DocType: Soil Texture,Loam,Lempung
apps/erpnext/erpnext/controllers/accounts_controller.py +700,Row {0}: Due Date cannot be before posting date,Baris {0}: Tanggal Jatuh Tempo tidak boleh sebelum tanggal posting
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Buat Entri Pembayaran
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Kuantitas untuk Item {0} harus kurang dari {1}
,Sales Invoice Trends,Trend Faktur Penjualan
DocType: Leave Application,Apply / Approve Leaves,Mohon / Approve Cuti
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Untuk
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Dapat merujuk baris hanya jika jenis biaya adalah 'On Sebelumnya Row Jumlah' atau 'Sebelumnya Row Jumlah'
DocType: Sales Order Item,Delivery Warehouse,Gudang Pengiriman
apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Pohon Pusat Biaya keuangan.
DocType: Serial No,Delivery Document No,Nomor Dokumen Pengiriman
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Silahkan mengatur &#39;Gain / Loss Account pada Asset Disposal&#39; di Perusahaan {0}
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Dapatkan Produk Dari Pembelian Penerimaan
DocType: Serial No,Creation Date,Tanggal Pembuatan
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Item {0} muncul beberapa kali dalam Daftar Harga {1}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +40,"Selling must be checked, if Applicable For is selected as {0}","Jual harus diperiksa, jika Berlaku Untuk dipilih sebagai {0}"
DocType: Production Plan Material Request,Material Request Date,Bahan Permintaan Tanggal
DocType: Purchase Order Item,Supplier Quotation Item,Quotation Stok Barang Supplier
DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Menonaktifkan penciptaan log waktu terhadap Order Produksi. Operasi tidak akan dilacak terhadap Orde Produksi
DocType: Student,Student Mobile Number,Mahasiswa Nomor Ponsel
DocType: Item,Has Variants,Memiliki Varian
apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Perbarui Tanggapan
apps/erpnext/erpnext/public/js/utils.js +226,You have already selected items from {0} {1},Anda sudah memilih item dari {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Nama Distribusi Bulanan
apps/erpnext/erpnext/stock/doctype/batch/batch.py +46,Batch ID is mandatory,Batch ID adalah wajib
DocType: Sales Person,Parent Sales Person,Induk Sales Person
apps/erpnext/erpnext/hub_node/page/hub/hub.js +180,High to Low,Tinggi ke Rendah
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Pilih programnya dulu
DocType: Patient Appointment,Patient Age,Usia pasien
apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Pengelolaan Proyek
DocType: Supplier,Supplier of Goods or Services.,Supplier Stok Barang atau Jasa.
DocType: Budget,Fiscal Year,Tahun Fiskal
DocType: Asset Maintenance Log,Planned,Berencana
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,Rekening piutang bawaan yang akan digunakan jika tidak diatur oleh Pasien untuk memesan biaya Konsultasi.
DocType: Vehicle Log,Fuel Price,Harga BBM
DocType: Budget,Budget,Anggaran belanja
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Setel Buka
apps/erpnext/erpnext/stock/doctype/item/item.py +247,Fixed Asset Item must be a non-stock item.,Fixed Asset Item harus barang non-persediaan.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Anggaran tidak dapat ditugaskan terhadap {0}, karena itu bukan Penghasilan atau Beban akun"
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Tercapai
DocType: Student Admission,Application Form Route,Form aplikasi Route
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Wilayah / Pelanggan
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,Tinggalkan Jenis {0} tidak dapat dialokasikan karena itu pergi tanpa membayar
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +166,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Baris {0}: Alokasi jumlah {1} harus kurang dari atau sama dengan faktur jumlah yang luar biasa {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,Dalam Kata-kata akan terlihat setelah Anda menyimpan Faktur Penjualan.
DocType: Lead,Follow Up,Mengikuti
DocType: Item,Is Sales Item,Barang Jualan
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Tree Item Grup
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,Stok Barang {0} tidak setup untuk Nomor Seri. Periksa Induk Barang
DocType: Maintenance Visit,Maintenance Time,Waktu Pemeliharaan
,Amount to Deliver,Jumlah untuk Dikirim
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Same item has been entered multiple times. {0},Item yang sama telah beberapa kali dimasukkan. {0}
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Jangka Tanggal Mulai tidak dapat lebih awal dari Tahun Tanggal Mulai Tahun Akademik yang istilah terkait (Tahun Akademik {}). Perbaiki tanggal dan coba lagi.
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +192,There were errors.,Ada kesalahan.
DocType: Guardian,Guardian Interests,wali Minat
DocType: Naming Series,Current Value,Nilai saat ini
apps/erpnext/erpnext/controllers/accounts_controller.py +272,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Beberapa tahun fiskal ada untuk tanggal {0}. Silakan set perusahaan di Tahun Anggaran
DocType: Education Settings,Instructor Records to be created by,Catatan Instruktur yang akan dibuat oleh
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} dibuat
DocType: GST Account,GST Account,Akun GST
DocType: Delivery Note Item,Against Sales Order,Berdasarkan Order Penjualan
,Serial No Status,Status Nomor Serial
DocType: Payment Entry Reference,Outstanding,terkemuka
DocType: Supplier,Warn POs,Peringatkan untuk POs
,Daily Timesheet Summary,Timesheet Ringkasan Harian
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Baris {0}: Untuk mengatur {1} periodisitas, perbedaan antara dari dan sampai saat ini \
 harus lebih besar dari atau sama dengan {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Hal ini didasarkan pada pergerakan persediaan. Lihat {0} untuk rincian
DocType: Pricing Rule,Selling,Penjualan
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Amount {0} {1} deducted against {2},Jumlah {0} {1} dipotong terhadap {2}
DocType: Employee,Salary Information,Informasi Gaji
DocType: Sales Person,Name and Employee ID,Nama dan ID Karyawan
apps/erpnext/erpnext/accounts/party.py +311,Due Date cannot be before Posting Date,Tanggal jatuh tempo tidak bisa sebelum Tanggal Posting
DocType: Website Item Group,Website Item Group,Situs Stok Barang Grup
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Tarif dan Pajak
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Please enter Reference date,Harap masukkan tanggal Referensi
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} entri pembayaran tidak dapat disaring oleh {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tabel untuk Item yang akan ditampilkan di Situs Web
DocType: Purchase Order Item Supplied,Supplied Qty,Qty Disupply
DocType: Purchase Order Item,Material Request Item,Item Permintaan Material
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Tree Item Grup.
DocType: Payroll Entry,Get Employee Details,Dapatkan Rincian Karyawan
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,Cannot refer row number greater than or equal to current row number for this Charge type,Tidak dapat merujuk nomor baris yang lebih besar dari atau sama dengan nomor baris saat ini untuk jenis Biaya ini
DocType: Asset,Sold,Terjual
,Item-wise Purchase History,Laporan Riwayat Pembelian berdasarkan Stok Barang/Item
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Silahkan klik 'Menghasilkan Jadwal' untuk mengambil Serial yang ditambahkan untuk Item {0}
DocType: Account,Frozen,Beku
,Open Production Orders,Order Produksi Aktif
DocType: Sales Invoice Payment,Base Amount (Company Currency),Dasar Penilaian (Mata Uang Perusahaan)
DocType: Payment Reconciliation Payment,Reference Row,referensi Row
DocType: Installation Note,Installation Time,Waktu Installasi
DocType: Sales Invoice,Accounting Details,Rincian Akuntansi
apps/erpnext/erpnext/setup/doctype/company/company.js +113,Delete all the Transactions for this Company,Hapus semua Transaksi untuk Perusahaan ini
DocType: Patient,O Positive,O Positif
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +200,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row #{0}: Operasi {1} tidak selesai untuk {2} jumlah Barang Jadi di Perintah Produksi # {3}. Harap perbarui status operasi melalui Log Waktu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investasi
DocType: Issue,Resolution Details,Detail Resolusi
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,Alokasi
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Kriteria Penerimaan
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Cukup masukkan Permintaan Bahan dalam tabel di atas
DocType: Item Attribute,Attribute Name,Nama Atribut
DocType: BOM,Show In Website,Tampilkan Di Website
DocType: Shopping Cart Settings,Show Quantity in Website,Tampilkan Kuantitas Website
DocType: Employee Loan Application,Total Payable Amount,Jumlah Total Hutang
DocType: Task,Expected Time (in hours),Waktu yang diharapkan (dalam jam)
DocType: Item Reorder,Check in (group),Check in (kelompok)
DocType: Soil Texture,Silt,Lanau
,Qty to Order,Kuantitas untuk diorder
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Account kepala di bawah Kewajiban atau Ekuitas, di mana Laba / Rugi akan dipesan"
apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Gantt chart dari semua tugas.
DocType: Opportunity,Mins to First Response,Menit untuk Respon Pertama
DocType: Pricing Rule,Margin Type,Margin Jenis
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} jam
DocType: Course,Default Grading Scale,Skala Grading bawaan
DocType: Appraisal,For Employee Name,Untuk Nama Karyawan
DocType: Holiday List,Clear Table,Bersihkan Table
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Slot yang tersedia
DocType: C-Form Invoice Detail,Invoice No,Nomor Faktur
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Melakukan pembayaran
DocType: Room,Room Name,Nama ruangan
DocType: Prescription Duration,Prescription Duration,Durasi Resep
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +100,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Cuti tidak dapat diterapkan / dibatalkan sebelum {0}, saldo cuti sudah pernah membawa-diteruskan dalam catatan alokasi cuti masa depan {1}"
DocType: Activity Cost,Costing Rate,Tingkat Biaya
apps/erpnext/erpnext/config/selling.py +229,Customer Addresses And Contacts,Alamat dan Kontak Pelanggan
,Campaign Efficiency,Efisiensi Promosi
DocType: Discussion,Discussion,Diskusi
DocType: Payment Entry,Transaction ID,ID transaksi
DocType: Volunteer,Anytime,Kapan saja
DocType: Patient,Surgical History,Sejarah Bedah
DocType: Employee,Resignation Letter Date,Tanggal Surat Pengunduran Diri
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Aturan harga selanjutnya disaring berdasarkan kuantitas.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Harap atur tanggal bergabung untuk karyawan {0}
DocType: Task,Total Billing Amount (via Time Sheet),Jumlah Total Penagihan (via Waktu Lembar)
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Pendapatan Pelanggan Rutin
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
DocType: Chapter,Chapter,Bab
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +200,{0} ({1}) must have role 'Expense Approver',{0} ({1}) harus memiliki akses sebagai 'Pemberi Izin Pengeluaran'
apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Pasangan
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +959,Select BOM and Qty for Production,Pilih BOM dan Qty untuk Produksi
DocType: Asset,Depreciation Schedule,Jadwal penyusutan
apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Alamat Mitra Penjualan Dan Kontak
DocType: Bank Reconciliation Detail,Against Account,Terhadap Akun
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,Half Day Date should be between From Date and To Date,Tanggal Setengah Hari harus di antara Tanggal Mulai dan Tanggal Akhir
DocType: Maintenance Schedule Detail,Actual Date,Tanggal Aktual
DocType: Item,Has Batch No,Bernomor Batch
apps/erpnext/erpnext/public/js/utils.js +100,Annual Billing: {0},Penagihan tahunan: {0}
apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Pajak Barang dan Jasa (GST India)
DocType: Delivery Note,Excise Page Number,Jumlah Halaman Excise
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +225,"Company, From Date and To Date is mandatory","Perusahaan, Dari Tanggal dan To Date adalah wajib"
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Dapatkan Konsultasi
DocType: Asset,Purchase Date,Tanggal Pembelian
DocType: Volunteer,Volunteer Type,Jenis Relawan
DocType: Student,Personal Details,Data Pribadi
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Silahkan mengatur &#39;Biaya Penyusutan Asset Center di Perusahaan {0}
,Maintenance Schedules,Jadwal pemeliharaan
DocType: Task,Actual End Date (via Time Sheet),Tanggal Akhir Aktual (dari Lembar Waktu)
DocType: Soil Texture,Soil Type,Jenis tanah
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Amount {0} {1} against {2} {3},Jumlah {0} {1} terhadap {2} {3}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +318,New Message,Pesan baru
,Quotation Trends,Trend Penawaran
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +159,Item Group not mentioned in item master for item {0},Item Grup tidak disebutkan dalam master Stok Barang untuk item {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +355,Debit To account must be a Receivable account,Debit Untuk akun harus rekening Piutang
DocType: Shipping Rule,Shipping Amount,Jumlah Pengiriman
DocType: Supplier Scorecard Period,Period Score,Skor Periode
apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Tambahkan Pelanggan
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Jumlah Pending
DocType: Lab Test Template,Special,Khusus
DocType: Purchase Order Item Supplied,Conversion Factor,Faktor konversi
DocType: Purchase Order,Delivered,Dikirim
,Vehicle Expenses,Beban kendaraan
DocType: Serial No,Invoice Details,Detail faktur
DocType: Grant Application,Show on Website,Tampilkan di Website
apps/erpnext/erpnext/assets/doctype/asset/asset.py +159,Expected value after useful life must be greater than or equal to {0},nilai yang diharapkan setelah masa manfaat harus lebih besar dari atau sama dengan {0}
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Mulai dari
DocType: Hub Category,Hub Category,Kategori Hub
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Nomor Kendaraan
DocType: Employee Loan,Loan Amount,Jumlah pinjaman
apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Tambahkan kop surat
DocType: Program Enrollment,Self-Driving Vehicle,Kendaraan Mengemudi Sendiri
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Supplier Scorecard Berdiri
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +420,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Bill of Material tidak ditemukan Item {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Jumlah cuti dialokasikan {0} tidak bisa kurang dari cuti yang telah disetujui {1} untuk periode
DocType: Journal Entry,Accounts Receivable,Piutang
,Supplier-Wise Sales Analytics,Sales Analitikal berdasarkan Supplier
DocType: Salary Structure,Select employees for current Salary Structure,Pilih karyawan untuk Struktur Gaji saat ini
DocType: Sales Invoice,Company Address Name,Nama alamat perusahaan
DocType: Production Order,Use Multi-Level BOM,Gunakan Multi-Level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Termasuk Entri Rekonsiliasi
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Kursus Orang Tua (Biarkan kosong, jika ini bukan bagian dari Kursus Orang Tua)"
DocType: Leave Control Panel,Leave blank if considered for all employee types,Biarkan kosong jika dipertimbangkan untuk semua jenis karyawan
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribusi Biaya Berdasarkan
apps/erpnext/erpnext/hooks.py +144,Timesheets,timesheets
DocType: HR Settings,HR Settings,Pengaturan Sumber Daya Manusia
DocType: Salary Slip,net pay info,net Info pay
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Nilai ini diperbarui dalam Daftar Harga Penjualan Standar.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +122,Expense Claim is pending approval. Only the Expense Approver can update status.,Klaim Pengeluaran sedang menunggu persetujuan. Hanya Penyetuju Pengeluaran dapat memperbarui status.
DocType: Email Digest,New Expenses,Beban baru
DocType: Purchase Invoice,Additional Discount Amount,Jumlah Potongan Tambahan
DocType: Patient,Patient Details,Rincian pasien
DocType: Patient,B Positive,B Positif
apps/erpnext/erpnext/controllers/accounts_controller.py +595,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Qty harus 1, sebagai item aset tetap. Silakan gunakan baris terpisah untuk beberapa qty."
DocType: Leave Block List Allow,Leave Block List Allow,Cuti Block List Izinkan
apps/erpnext/erpnext/setup/doctype/company/company.py +310,Abbr can not be blank or space,Singkatan tidak boleh kosong atau spasi
DocType: Patient Medical Record,Patient Medical Record,Catatan Medis Pasien
apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Kelompok Non-kelompok
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Olahraga
DocType: Loan Type,Loan Name,pinjaman Nama
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Total Aktual
DocType: Lab Test UOM,Test UOM,Uji UOM
DocType: Student Siblings,Student Siblings,Saudara mahasiswa
apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Satuan
apps/erpnext/erpnext/stock/get_item_details.py +136,Please specify Company,Silakan tentukan Perusahaan
,Customer Acquisition and Loyalty,Akuisisi dan Loyalitas Pelanggan
DocType: Asset Maintenance Task,Maintenance Task,Tugas pemeliharaan
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Gudang di mana Anda menyimpan barang-barang yang ditolak/reject
DocType: Production Order,Skip Material Transfer,Lewati Transfer Material
apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Tidak dapat menemukan nilai tukar untuk {0} sampai {1} untuk tanggal kunci {2}. Buat catatan Currency Exchange secara manual
DocType: POS Profile,Price List,Daftar Harga
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} adalah Tahun Anggaran bawaan. Silahkan memuat kembali browser Anda agar perubahan dapat terwujud.
apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,Beban Klaim
DocType: Issue,Support,Support
,BOM Search,Pencarian BOM
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publish &quot;In Stock&quot; atau &quot;Not in Stock&quot; di Hub berdasarkan stok yang ada di gudang ini.
DocType: Vehicle,Fuel Type,Jenis bahan bakar
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Silakan tentukan mata uang di Perusahaan
DocType: Workstation,Wages per hour,Upah per jam
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Saldo Persediaan di Batch {0} akan menjadi negatif {1} untuk Barang {2} di Gudang {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Berikut Permintaan Bahan telah dibesarkan secara otomatis berdasarkan tingkat re-order Item
DocType: Email Digest,Pending Sales Orders,Pending Order Penjualan
apps/erpnext/erpnext/controllers/accounts_controller.py +311,Account {0} is invalid. Account Currency must be {1},Akun {0} tidak berlaku. Mata Uang Akun harus {1}
DocType: Healthcare Settings,Remind Before,Ingatkan sebelumnya
apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Faktor UOM Konversi diperlukan berturut-turut {0}
DocType: Production Plan Item,material_request_item,material_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1060,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Dokumen Referensi Type harus menjadi salah satu Sales Order, Faktur Penjualan atau Journal Entri"
DocType: Salary Component,Deduction,Deduksi
DocType: Item,Retain Sample,Simpan sampel
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Row {0}: Dari Waktu dan To Waktu adalah wajib.
DocType: Stock Reconciliation Item,Amount Difference,jumlah Perbedaan
apps/erpnext/erpnext/stock/get_item_details.py +354,Item Price added for {0} in Price List {1},Item Harga ditambahkan untuk {0} di Daftar Harga {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Cukup masukkan Id Karyawan Sales Person ini
DocType: Territory,Classification of Customers by region,Klasifikasi Pelanggan menurut wilayah
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,Dalam produksi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +59,Difference Amount must be zero,Perbedaan Jumlah harus nol
DocType: Project,Gross Margin,Margin kotor
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,Please enter Production Item first,Entrikan Produksi Stok Barang terlebih dahulu
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Dihitung keseimbangan Laporan Bank
DocType: Normal Test Template,Normal Test Template,Template Uji Normal
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,Pengguna Non-aktif
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +913,Quotation,Penawaran
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +982,Cannot set a received RFQ to No Quote,Tidak dapat mengatur RFQ yang diterima ke No Quote
DocType: Quotation,QTN-,QTN-
DocType: Salary Slip,Total Deduction,Jumlah Deduksi
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +15,Select an account to print in account currency,Pilih akun yang akan dicetak dalam mata uang akun
,Production Analytics,Analytics produksi
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Hal ini didasarkan pada transaksi melawan Pasien ini. Lihat garis waktu di bawah untuk rinciannya
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +201,Cost Updated,Biaya Diperbarui
DocType: Patient,Date of Birth,Tanggal Lahir
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,Item {0} telah dikembalikan
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Tahun Anggaran ** mewakili Tahun Keuangan. Semua entri akuntansi dan transaksi besar lainnya dilacak terhadap Tahun Anggaran ** **.
DocType: Opportunity,Customer / Lead Address,Alamat Pelanggan / Prospek
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Penyiapan Scorecard Pemasok
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Nama Rencana Penilaian
apps/erpnext/erpnext/stock/doctype/item/item.py +222,Warning: Invalid SSL certificate on attachment {0},Peringatan: Sertifikat SSL tidak valid pada lampiran {0}
apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Prospek membantu Anda mendapatkan bisnis, tambahkan semua kontak Anda sebagai prospek Anda"
DocType: Production Order Operation,Actual Operation Time,Waktu Operasi Aktual
DocType: Authorization Rule,Applicable To (User),Berlaku Untuk (User)
DocType: Purchase Taxes and Charges,Deduct,Pengurangan
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Job Description,Deskripsi Bidang Kerja
DocType: Student Applicant,Applied,Terapan
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +863,Re-open,Re-terbuka
DocType: Sales Invoice Item,Qty as per Stock UOM,Kuantitas sesuai UOM Persediaan
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Nama Guardian2
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Karakter khusus kecuali ""-"" ""."", ""#"", dan ""/"" tidak diperbolehkan dalam penamaan seri"
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Pantau Kampanye Penjualan. Pantau Prospek, Penawaran, Perintah Penjualan dll dari Kampanye untuk mengukur Return on Investment."
DocType: Expense Claim,Approver,Approver
,SO Qty,SO Qty
DocType: Guardian,Work Address,kerja Alamat
DocType: Appraisal,Calculate Total Score,Hitung Total Skor
DocType: Asset Repair,Manufacturing Manager,Manajer Manufaktur
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serial ada {0} masih dalam garansi upto {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Nilai Diijinkan Minimal
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +42,User {0} already exists,Pengguna {0} sudah ada
apps/erpnext/erpnext/hooks.py +109,Shipments,Pengiriman
DocType: Payment Entry,Total Allocated Amount (Company Currency),Total Dialokasikan Jumlah (Perusahaan Mata Uang)
DocType: Purchase Order Item,To be delivered to customer,Akan dikirimkan ke pelanggan
DocType: BOM,Scrap Material Cost,Scrap Material Biaya
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,Serial ada {0} bukan milik Gudang setiap
DocType: Grant Application,Email Notification Sent,Notifikasi Email Terkirim
DocType: Purchase Invoice,In Words (Company Currency),Dalam Kata-kata (Perusahaan Mata Uang)
DocType: Pricing Rule,Supplier,Supplier
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Tampilkan Rincian Pembayaran
DocType: Consultation,Consultation Time,Waktu Konsultasi
DocType: C-Form,Quarter,Seperempat
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Beban lain-lain
DocType: Global Defaults,Default Company,Standar Perusahaan
apps/erpnext/erpnext/controllers/stock_controller.py +227,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Akun Beban atau Selisih adalah wajib untuk Barang {0} karena berdampak pada keseluruhan nilai persediaan
DocType: Payment Request,PR,PR
DocType: Cheque Print Template,Bank Name,Nama Bank
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +29,-Above,-Di Atas
DocType: Employee Loan,Employee Loan Account,Rekening Pinjaman karyawan
DocType: Leave Application,Total Leave Days,Jumlah Cuti Hari
DocType: Email Digest,Note: Email will not be sent to disabled users,Catatan: Surel tidak akan dikirim ke pengguna non-aktif
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Jumlah Interaksi
apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Pengaturan Variasi Item
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Pilih Perusahaan ...
DocType: Leave Control Panel,Leave blank if considered for all departments,Biarkan kosong jika dianggap untuk semua departemen
apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Jenis pekerjaan (permanen, kontrak, magang dll)."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +421,{0} is mandatory for Item {1},{0} adalah wajib untuk Item {1}
DocType: Payroll Entry,Fortnightly,sekali dua minggu
DocType: Currency Exchange,From Currency,Dari mata uang
DocType: Vital Signs,Weight (In Kilogram),Berat (dalam Kilogram)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",bab / chapter_name kosongkan secara otomatis setelah bab save.
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +169,Please set GST Accounts in GST Settings,Harap setel akun GST di GST Settings
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31,Type of Business,Jenis bisnis
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Silakan pilih Jumlah Alokasi, Faktur Jenis dan Faktur Nomor di minimal satu baris"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Biaya Pembelian New
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Sales Order yang diperlukan untuk Item {0}
DocType: Grant Application,Grant Description,Deskripsi Hibah
DocType: Purchase Invoice Item,Rate (Company Currency),Rate (Perusahaan Mata Uang)
DocType: Student Guardian,Others,Lainnya
DocType: Payment Entry,Unallocated Amount,Jumlah yang tidak terisi
apps/erpnext/erpnext/templates/includes/product_page.js +71,Cannot find a matching Item. Please select some other value for {0}.,Tidak dapat menemukan yang cocok Item. Silakan pilih beberapa nilai lain untuk {0}.
DocType: POS Profile,Taxes and Charges,Pajak dan Biaya
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produk atau Jasa yang dibeli, dijual atau disimpan dalam persediaan."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Tidak ada perbaruan lagi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Tidak dapat memilih jenis biaya sebagai 'Pada Row Sebelumnya Jumlah' atau 'On Sebelumnya Row Jumlah' untuk baris terlebih dahulu
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Ini mencakup semua scorecard yang terkait dengan Setup ini
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Barang Turunan tidak boleh berupa sebuah Bundel Produk. Silahkan hapus barang `{0}` dan simpan
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Perbankan
apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,menambahkan Timesheets
DocType: Vehicle Service,Service Item,layanan Barang
DocType: Bank Guarantee,Bank Guarantee,Bank Garansi
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Silahkan klik 'Menghasilkan Jadwal' untuk mendapatkan jadwal
DocType: Bin,Ordered Quantity,Qty Terpesan/Terorder
apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","misalnya ""Membangun alat untuk pembangun """
DocType: Grading Scale,Grading Scale Intervals,Grading Scale Interval
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Entri Akuntansi untuk {2} hanya dapat dilakukan dalam bentuk mata uang: {3}
DocType: Fee Schedule,In Process,Dalam Proses
DocType: Authorization Rule,Itemwise Discount,Diskon berdasarkan Item/Stok
apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Pohon rekening keuangan.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +362,{0} against Sales Order {1},{0} terhadap Order Penjualan {1}
DocType: Account,Fixed Asset,Asset Tetap
apps/erpnext/erpnext/config/stock.py +320,Serialized Inventory,Persediaan memiliki serial
DocType: Employee Loan,Account Info,Info akun
DocType: Activity Type,Default Billing Rate,Standar Tingkat Penagihan
DocType: Fees,Include Payment,Sertakan Pembayaran
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Kelompok Siswa dibuat.
DocType: Sales Invoice,Total Billing Amount,Jumlah Total Tagihan
apps/erpnext/erpnext/hr/doctype/daily_work_summary_settings/daily_work_summary_settings.py +17,There must be a default incoming Email Account enabled for this to work. Please setup a default incoming Email Account (POP/IMAP) and try again.,Harus ada Akun Email masuk default yang aktif supaya hal ini bisa bekerja. Silakan atur Akun Email masuk default (POP / IMAP) dan coba lagi.
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Program di Struktur Biaya dan Kelompok Pelajar {0} berbeda.
DocType: Fee Schedule,Receivable Account,Akun Piutang
apps/erpnext/erpnext/controllers/accounts_controller.py +617,Row #{0}: Asset {1} is already {2},Row # {0}: Aset {1} sudah {2}
DocType: Quotation Item,Stock Balance,Saldo Persediaan
apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Nota Penjualan untuk Pembayaran
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,CEO
DocType: Purchase Invoice,With Payment of Tax,Dengan pembayaran pajak
DocType: Expense Claim Detail,Expense Claim Detail,Detail Klaim Biaya
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLICATE UNTUK PEMASOK
DocType: Land Unit,Is Container,Adalah kontainer
DocType: Crop Cycle,This will be day 1 of the crop cycle,Ini akan menjadi hari 1 dari siklus panen
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +869,Please select correct account,Silakan pilih akun yang benar
DocType: Purchase Invoice Item,Weight UOM,Berat UOM
DocType: Salary Structure Employee,Salary Structure Employee,Struktur Gaji Karyawan
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Tampilkan Variant Attributes
DocType: Student,Blood Group,Golongan Darah
DocType: Course,Course Name,Nama kursus
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Pengguna yang dapat menyetujui aplikasi cuti karyawan tertentu yang
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Peralatan Kantor
DocType: Purchase Invoice Item,Qty,Kuantitas
DocType: Fiscal Year,Companies,Perusahaan
DocType: Supplier Scorecard,Scoring Setup,Setup Scoring
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronik
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Munculkan Permintaan Material ketika persediaan mencapai tingkat pesan ulang
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Full-time
DocType: Payroll Entry,Employees,Para karyawan
DocType: Employee,Contact Details,Kontak Detail
DocType: C-Form,Received Date,Diterima Tanggal
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Jika Anda telah membuat template standar dalam Penjualan Pajak dan Biaya Template, pilih salah satu dan klik pada tombol di bawah ini."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Nilai Dasar (Mata Uang Perusahaan)
DocType: Student,Guardians,Penjaga
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Harga tidak akan ditampilkan jika Harga Daftar tidak diatur
DocType: Stock Entry,Total Incoming Value,Total nilai masuk
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +349,Debit To is required,Debit Untuk diperlukan
apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets membantu melacak waktu, biaya dan penagihan untuk kegiatan yang dilakukan oleh tim Anda"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Pembelian Daftar Harga
apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Template dari variabel scorecard pemasok.
DocType: Offer Letter Term,Offer Term,Penawaran Term
DocType: Asset,Quality Manager,Manajer Mutu
DocType: Job Applicant,Job Opening,Lowongan Pekerjaan
DocType: Payment Reconciliation,Payment Reconciliation,Rekonsiliasi Pembayaran
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Silahkan Pilih Pihak penanggung jawab
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Teknologi
DocType: Hub Settings,Unregister from Hub,Unregister dari Hub
apps/erpnext/erpnext/public/js/utils.js +102,Total Unpaid: {0},Total Tunggakan: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Operasi Situs
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Surat Penawaran
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Menghasilkan Permintaan Material (MRP) dan Order Produksi.
DocType: Supplier Scorecard,Supplier Score,Skor Pemasok
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +87,Total Invoiced Amt,Jumlah Nilai Tagihan
DocType: Supplier,Warn RFQs,Peringatkan untuk RFQs
DocType: BOM,Conversion Rate,Tingkat konversi
apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Cari produk
DocType: Assessment Plan,To Time,Untuk Waktu
DocType: Authorization Rule,Approving Role (above authorized value),Menyetujui Peran (di atas nilai yang berwenang)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Kredit Untuk akun harus rekening Hutang
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Silakan pilih Student Admission yang wajib diisi pemohon uang pelajar
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +338,BOM recursion: {0} cannot be parent or child of {2},BOM recursion: {0} tidak bisa menjadi induk atau cabang dari {2}
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +23,Please select a Price List to publish pricing,Silakan pilih Daftar Harga untuk menerbitkan harga
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Daftar anggaran
DocType: Production Order Operation,Completed Qty,Qty Selesai
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +146,"For {0}, only debit accounts can be linked against another credit entry","Untuk {0}, hanya rekening debit dapat dihubungkan dengan entri kredit lain"
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Daftar Harga {0} dinonaktifkan
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Row {0}: Selesai Qty tidak bisa lebih dari {1} untuk operasi {2}
DocType: Manufacturing Settings,Allow Overtime,Izinkan Lembur
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serial Barang {0} tidak dapat diperbarui menggunakan Rekonsiliasi Persediaan, gunakan Entri Persediaan"
DocType: Training Event Employee,Training Event Employee,Acara Pelatihan Karyawan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1009,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Sampel Maksimum - {0} dapat disimpan untuk Batch {1} dan Item {2}.
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Tambahkan Slot Waktu
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Nomer Seri diperlukan untuk Item {1}. Anda menyediakan {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Nilai Tingkat Penilaian Saat ini
DocType: Item,Customer Item Codes,Kode Produk Pelanggan
DocType: Training Event,Advance,Muka
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,for making recurring again.,untuk membuat berulang lagi.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Efek Gain / Loss
DocType: Opportunity,Lost Reason,Alasan Kehilangan
apps/erpnext/erpnext/controllers/accounts_controller.py +264,Row #{0}: Account {1} does not belong to company {2},Baris # {0}: Akun {1} bukan milik perusahaan {2}
apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Alamat baru
DocType: Quality Inspection,Sample Size,Ukuran Sampel
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Masukkan Dokumen Penerimaan
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,All items have already been invoiced,Semua Stok Barang telah tertagih
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',Silakan tentukan valid 'Dari Kasus No'
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,Pusat biaya lebih lanjut dapat dibuat di bawah Grup tetapi entri dapat dilakukan terhadap non-Grup
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Pengguna dan Perizinan
DocType: Vehicle Log,VLOG.,VLOG.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +994,Production Orders Created: {0},Produksi Pesanan Dibuat: {0}
DocType: Branch,Branch,Cabang
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Pengguna Pemenuhan
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Percetakan dan Branding
DocType: Company,Total Monthly Sales,Total Penjualan Bulanan
DocType: Agriculture Analysis Criteria,Weather,Cuaca
DocType: Bin,Actual Quantity,Kuantitas Aktual
DocType: Shipping Rule,example: Next Day Shipping,Contoh: Hari Berikutnya Pengiriman
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serial No {0} tidak ditemukan
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +289,Subscription has been {0},Langganan telah {0}
DocType: Fee Schedule Program,Fee Schedule Program,Program Jadwal Biaya
DocType: Fee Schedule Program,Student Batch,Mahasiswa Batch
apps/erpnext/erpnext/utilities/activation.py +119,Make Student,membuat Siswa
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
apps/erpnext/erpnext/projects/doctype/project/project.py +214,You have been invited to collaborate on the project: {0},Anda telah diundang untuk berkolaborasi pada proyek: {0}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Physician not available on {0},Dokter tidak tersedia di {0}
DocType: Leave Block List Date,Block Date,Blok Tanggal
DocType: Crop,Crop,Tanaman
DocType: Purchase Receipt,Supplier Delivery Note,Catatan Pengiriman Supplier
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Terapkan Sekarang
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Sebenarnya Qty {0} / Menunggu Qty {1}
DocType: Purchase Invoice,E-commerce GSTIN,E-commerce GSTIN
DocType: Sales Order,Not Delivered,Tidak Terkirim
,Bank Clearance Summary,Ringkasan Kliring Bank
apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Buat dan kelola surel ringkasan harian, mingguan dan bulanan."
DocType: Appraisal Goal,Appraisal Goal,Penilaian Pencapaian
DocType: Stock Reconciliation Item,Current Amount,Jumlah saat ini
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,Bangunan
DocType: Fee Schedule,Fee Structure,Struktur biaya
DocType: Timesheet Detail,Costing Amount,Nilai Jumlah Biaya
DocType: Student Admission Program,Application Fee,Biaya aplikasi
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,Submit Salary Slip,Kirim Slip Gaji
apps/erpnext/erpnext/controllers/selling_controller.py +136,Maxiumm discount for Item {0} is {1}%,Diskon Maxiumm untuk Item {0} adalah {1}%
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Impor Secara massal
DocType: Sales Partner,Address & Contacts,Alamat & Kontak
DocType: SMS Log,Sender Name,Nama Pengirim
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kriteria Analisis Pertanian
apps/erpnext/erpnext/hub_node/page/hub/hub.js +193,Sort by Criteria,Urutkan menurut Kriteria
DocType: POS Profile,[Select],[Pilih]
DocType: Vital Signs,Blood Pressure (diastolic),Tekanan Darah (diastolik)
DocType: SMS Log,Sent To,Dikirim Ke
DocType: Agriculture Task,Holiday Management,Manajemen liburan
DocType: Payment Request,Make Sales Invoice,Buat Faktur Penjualan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,software
apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,Next Contact Date cannot be in the past,Berikutnya Hubungi Tanggal tidak dapat di masa lalu
DocType: Company,For Reference Only.,Untuk referensi saja.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Dokter {0} tidak tersedia di {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +2539,Select Batch No,Pilih Batch No
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +57,Invalid {0}: {1},Valid {0}: {1}
,GSTR-1,GSTR-1
DocType: Purchase Invoice,PINV-RET-,PINV-RET-
DocType: Fee Validity,Reference Inv,Referensi Inv
DocType: Sales Invoice Advance,Advance Amount,Jumlah Uang Muka
DocType: Manufacturing Settings,Capacity Planning,Perencanaan Kapasitas
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Penyesuaian Pembulatan (Mata Uang Perusahaan
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,'Dari Tanggal' diperlukan
DocType: Journal Entry,Reference Number,Nomor Referensi
DocType: Employee,Employment Details,Rincian Pekerjaan
DocType: Employee,New Workplace,Tempat Kerja Baru
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Tetapkan untuk ditutup
apps/erpnext/erpnext/stock/get_item_details.py +125,No Item with Barcode {0},Ada Stok Barang dengan Barcode {0}
DocType: Normal Test Items,Require Result Value,Mengharuskan Nilai Hasil
DocType: Item,Show a slideshow at the top of the page,Tampilkan slideshow di bagian atas halaman
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +517,Boms,BOMS
apps/erpnext/erpnext/stock/doctype/item/item.py +151,Stores,Toko
DocType: Project Type,Projects Manager,Manajer Proyek
DocType: Serial No,Delivery Time,Waktu Pengiriman
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Umur Berdasarkan
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +66,Appointment cancelled,Penunjukan dibatalkan
DocType: Item,End of Life,Akhir Riwayat
apps/erpnext/erpnext/demo/setup/setup_data.py +331,Travel,Perjalanan
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +182,No active or default Salary Structure found for employee {0} for the given dates,Tidak ada yang aktif atau gaji standar Struktur ditemukan untuk karyawan {0} untuk tanggal tertentu
DocType: Leave Block List,Allow Users,Izinkan Pengguna
DocType: Purchase Order,Customer Mobile No,Nomor Seluler Pelanggan
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Pengulangan
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Melacak Penghasilan terpisah dan Beban untuk vertikal produk atau divisi.
DocType: Rename Tool,Rename Tool,Alat Perubahan Nama
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Perbarui Biaya
DocType: Item Reorder,Item Reorder,Item Reorder
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Slip acara Gaji
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +848,Transfer Material,Transfer Material/Stok Barang
DocType: Fees,Send Payment Request,Kirim Permintaan Pembayaran
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Tentukan operasi, biaya operasi dan memberikan Operation unik ada pada operasi Anda."
DocType: Water Analysis,Origin,Asal
apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Dokumen ini adalah lebih dari batas oleh {0} {1} untuk item {4}. Apakah Anda membuat yang lain {3} terhadap yang sama {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js +1142,Please set recurring after saving,Silahkan mengatur berulang setelah menyimpan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +756,Select change amount account,Pilih akun berubah jumlah
DocType: Purchase Invoice,Price List Currency,Daftar Harga Mata uang
DocType: Naming Series,User must always select,Pengguna harus selalu pilih
DocType: Stock Settings,Allow Negative Stock,Izinkan persediaan negatif
DocType: Installation Note,Installation Note,Nota Installasi
DocType: Soil Texture,Clay,Tanah liat
DocType: Topic,Topic,Tema
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Arus Kas dari Pendanaan
DocType: Budget Account,Budget Account,Akun anggaran
DocType: Quality Inspection,Verified By,Diverifikasi oleh
apps/erpnext/erpnext/setup/doctype/company/company.py +77,"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."
DocType: Grading Scale Interval,Grade Description,kelas Keterangan
DocType: Stock Entry,Purchase Receipt No,No Nota Penerimaan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Uang Earnest
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Lacak
DocType: Asset Maintenance Log,Actions performed,Tindakan dilakukan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Sumber Dana (Kewajiban)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +411,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Kuantitas di baris {0} ({1}) harus sama dengan jumlah yang diproduksi {2}
DocType: Supplier Scorecard Scoring Standing,Employee,Karyawan
DocType: Asset Repair,Failure Date,Tanggal Kegagalan
DocType: Sample Collection,Collected Time,Waktu yang Dikumpulkan
apps/erpnext/erpnext/config/healthcare.py +134,Test Sample.,Contoh uji
DocType: Company,Sales Monthly History,Riwayat Bulanan Penjualan
DocType: Asset Maintenance Task,Next Due Date,Tanggal Jatuh Tempo Berikutnya
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Pilih Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +242,{0} {1} is fully billed,{0} {1} telah ditagih sepenuhnya
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +47,Vital Signs,Tanda-tanda vital
DocType: Training Event,End Time,Waktu Akhir
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Struktur Gaji aktif {0} ditemukan untuk karyawan {1} untuk tanggal yang diberikan
DocType: Payment Entry,Payment Deductions or Loss,Pengurangan pembayaran atau Rugi
DocType: Soil Analysis,Soil Analysis Criterias,Kriteria Analisis Tanah
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Ketentuan kontrak standar untuk Penjualan atau Pembelian.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Group by Voucher
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Yakin ingin membatalkan janji temu ini?
apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,Pipeline penjualan
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},Silakan set account default di Komponen Gaji {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Diperlukan pada
DocType: Rename Tool,File to Rename,Nama File untuk Diganti
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Silakan pilih BOM untuk Item di Row {0}
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Akun {0} tidak sesuai Perusahaan {1} dalam Mode Akun: {2}
apps/erpnext/erpnext/controllers/buying_controller.py +289,Specified BOM {0} does not exist for Item {1},Ditentukan BOM {0} tidak ada untuk Item {1}
DocType: Soil Texture,Sandy Loam,Sandy Loam
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Jadwal pemeliharaan {0} harus dibatalkan sebelum membatalkan Sales Order ini
DocType: POS Profile,Applicable for Users,Berlaku untuk Pengguna
DocType: Notification Control,Expense Claim Approved,Klaim Biaya Disetujui
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,Salary Slip of employee {0} already created for this period,Slip Gaji karyawan {0} sudah dibuat untuk periode ini
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Farmasi
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Biaya Produk Dibeli
DocType: Selling Settings,Sales Order Required,Nota Penjualan Diperlukan
DocType: Purchase Invoice,Credit To,Kredit Untuk
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Prospek / Pelanggan Aktif
DocType: Employee Education,Post Graduate,Pasca Sarjana
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Jadwal pemeliharaan Detil
DocType: Supplier Scorecard,Warn for new Purchase Orders,Peringatkan untuk Pesanan Pembelian baru
DocType: Quality Inspection Reading,Reading 9,Membaca 9
DocType: Supplier,Is Frozen,Dibekukan
apps/erpnext/erpnext/stock/utils.py +221,Group node warehouse is not allowed to select for transactions,gudang kelompok simpul tidak diperbolehkan untuk memilih untuk transaksi
DocType: Buying Settings,Buying Settings,Setting Pembelian
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,No. BOM untuk Barang Jadi
DocType: Upload Attendance,Attendance To Date,Kehadiran Sampai Tanggal
DocType: Request for Quotation Supplier,No Quote,Tidak ada kutipan
DocType: Warranty Claim,Raised By,Diangkat Oleh
DocType: Payment Gateway Account,Payment Account,Akun Pembayaran
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +906,Please specify Company to proceed,Silahkan tentukan Perusahaan untuk melanjutkan
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Perubahan bersih Piutang
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Kompensasi Off
DocType: Offer Letter,Accepted,Diterima
DocType: Grant Application,Organization,Organisasi
DocType: BOM Update Tool,BOM Update Tool,Alat Pembaruan BOM
DocType: SG Creation Tool Course,Student Group Name,Nama Kelompok Mahasiswa
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Tampilkan tampilan yang meledak
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Menciptakan Biaya
apps/erpnext/erpnext/setup/doctype/company/company.js +91,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,Pastikan Anda benar-benar ingin menghapus semua transaksi untuk perusahaan ini. Data master Anda akan tetap seperti itu. Tindakan ini tidak bisa dibatalkan.
DocType: Room,Room Number,Nomor kamar
apps/erpnext/erpnext/utilities/transaction_base.py +101,Invalid reference {0} {1},Referensi yang tidak valid {0} {1}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) tidak dapat lebih besar dari jumlah yang direncanakan ({2}) di Perintah Produksi {3}
DocType: Shipping Rule,Shipping Rule Label,Peraturan Pengiriman Label
DocType: Journal Entry Account,Payroll Entry,Entri Penggajian
apps/erpnext/erpnext/setup/doctype/company/company.js +35,Make Tax Template,Buat Template Pajak
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Forum pengguna
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +308,Raw Materials cannot be blank.,Bahan baku tidak boleh kosong.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +485,"Could not update stock, invoice contains drop shipping item.","Tidak bisa memperbarui persediaan, faktur berisi barang titipan."
DocType: Lab Test Sample,Lab Test Sample,Sampel Uji Lab
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +492,Quick Journal Entry,Jurnal Entry Cepat
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,Anda tidak dapat mengubah kurs jika BOM disebutkan atas tiap barang
DocType: Restaurant,Invoice Series Prefix,Awalan Seri Faktur
DocType: Employee,Previous Work Experience,Pengalaman Kerja Sebelumnya
DocType: Stock Entry,For Quantity,Untuk Kuantitas
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Entrikan Planned Qty untuk Item {0} pada baris {1}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +102,Google Maps integration is not enabled,Integrasi Google Maps tidak diaktifkan
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,{0} {1} is not submitted,{0} {1} belum dikirim
DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Order produksi yang terpisah akan dibuat untuk setiap item Stok Barang jadi.
DocType: Member,Membership Expiry Date,Tanggal Kedaluwarsa Keanggotaan
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} harus negatif dalam dokumen retur
,Minutes to First Response for Issues,Menit ke Response Pertama untuk Masalah
DocType: Purchase Invoice,Terms and Conditions1,Syarat dan Conditions1
apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,Nama lembaga yang Anda menyiapkan sistem ini.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Pencatatan Akuntansi telah dibekukan sampai tanggal ini, tidak seorang pun yang bisa melakukan / memodifikasi pencatatan kecuali peran yang telah ditentukan di bawah ini."
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Harap menyimpan dokumen sebelum menghasilkan jadwal pemeliharaan
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Harga terbaru diperbarui di semua BOM
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Status proyek
DocType: UOM,Check this to disallow fractions. (for Nos),Centang untuk melarang fraksi. (Untuk Nos)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +424,The following Production Orders were created:,Berikut Pesanan Produksi diciptakan:
DocType: Student Admission Program,Naming Series (for Student Applicant),Penamaan Series (untuk Mahasiswa Pemohon)
DocType: Delivery Note,Transporter Name,Transporter Nama
DocType: Authorization Rule,Authorized Value,Nilai Disetujui
DocType: BOM,Show Operations,Tampilkan Operasi
,Minutes to First Response for Opportunity,Menit ke Response Pertama untuk Peluang
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Jumlah Absen
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +840,Item or Warehouse for row {0} does not match Material Request,Item atau Gudang untuk baris {0} Material tidak cocok Permintaan
apps/erpnext/erpnext/config/stock.py +187,Unit of Measure,Satuan Ukur
DocType: Fiscal Year,Year End Date,Tanggal Akhir Tahun
DocType: Task Depends On,Task Depends On,Tugas Tergantung Pada
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1024,Opportunity,Peluang
,Completed Production Orders,Order Produksi Selesai
DocType: Operation,Default Workstation,Standar Workstation
DocType: Notification Control,Expense Claim Approved Message,Beban Klaim Disetujui Pesan
DocType: Payment Entry,Deductions or Loss,Pemotongan atau Rugi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +245,{0} {1} is closed,{0} {1} tertutup
DocType: Email Digest,How frequently?,Seberapa sering?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Total Dikumpulkan: {0}
DocType: Purchase Receipt,Get Current Stock,Dapatkan Persediaan saat ini
apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Tree Bill of Material
DocType: Student,Joining Date,Tanggal Bergabung
,Employees working on a holiday,Karyawan yang bekerja pada hari libur
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Hadir
DocType: Project,% Complete Method,% Metode Lengkap
apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Obat
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Tanggal mulai pemeliharaan tidak bisa sebelum tanggal pengiriman untuk Serial No {0}
DocType: Production Order,Actual End Date,Tanggal Akhir Aktual
DocType: BOM,Operating Cost (Company Currency),Biaya operasi (Perusahaan Mata Uang)
DocType: Purchase Invoice,PINV-,PINV-
DocType: Authorization Rule,Applicable To (Role),Berlaku Untuk (Peran)
DocType: BOM Update Tool,Replace BOM,Ganti BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Kode {0} sudah ada
DocType: Employee Advance,Purpose,Tujuan
DocType: Company,Fixed Asset Depreciation Settings,Pengaturan Penyusutan Aset Tetap
DocType: Item,Will also apply for variants unless overrridden,Juga akan berlaku untuk varian kecuali tertimpa
DocType: Purchase Invoice,Advances,Advances
DocType: Production Order,Manufacture against Material Request,Memproduksi terhadap Permintaan Bahan
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Kelompok Penilaian:
DocType: Item Reorder,Request for,Meminta
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Menyetujui Pengguna tidak bisa sama dengan pengguna aturan yang Berlaku Untuk
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Tarif Dasar (sesuai UOM Persediaan)
DocType: SMS Log,No of Requested SMS,Tidak ada dari Diminta SMS
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,Tinggalkan Tanpa Bayar tidak sesuai dengan catatan Cuti Aplikasi disetujui
DocType: Campaign,Campaign-.####,Promosi-.####
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Langkah selanjutnya
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +794,Please supply the specified items at the best possible rates,Silakan memasok barang-barang tertentu dengan tarif terbaik
DocType: Membership,USD,USD
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Membuat Invoice
DocType: Selling Settings,Auto close Opportunity after 15 days,Auto Peluang dekat setelah 15 hari
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +82,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Pesanan Pembelian tidak diizinkan untuk {0} karena kartu skor berdiri {1}.
apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,akhir Tahun
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Penawaran/Prospek %
apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,Kontrak Tanggal Akhir harus lebih besar dari Tanggal Bergabung
DocType: Driver,Driver,Sopir
DocType: Vital Signs,Nutrition Values,Nilai gizi
DocType: Lab Test Template,Is billable,Apakah bisa ditagih
DocType: Delivery Note,DN-,DN-
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}",Baik &quot;Jadwal Dokter&quot; dan Waktu Per Penunjukan &quot;harus ditetapkan untuk Dr {0}
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Seorang distributor pihak ketiga / agen / komisi agen / affiliate / reseller yang menjual produk-produk perusahaan untuk komisi.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +374,{0} against Purchase Order {1},{0} terhadap Purchase Order {1}
DocType: Patient,Patient Demographics,Demografi pasien
DocType: Task,Actual Start Date (via Time Sheet),Aktual Mulai Tanggal (via Waktu Lembar)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Ini adalah situs contoh auto-dihasilkan dari ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Rentang Ageing 1
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +226,Total advance amount cannot be greater than total claimed amount,Jumlah uang muka total tidak boleh lebih besar dari jumlah total yang diklaim
DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
10. Add or Deduct: Whether you want to add or deduct the tax.","Pajak standar template yang dapat diterapkan untuk semua Transaksi Pembelian. Template ini dapat berisi daftar kepala pajak dan juga kepala biaya lain seperti ""Pengiriman"", ""Asuransi"", ""Penanganan"" dll 

 #### Catatan 

 Tarif pajak Anda mendefinisikan sini akan menjadi tarif pajak standar untuk semua item ** **. Jika ada Item ** ** yang memiliki tarif yang berbeda, mereka harus ditambahkan dalam ** Pajak Stok Barang ** meja di ** Stok Barang ** menguasai.

 #### Deskripsi Kolom 

 1. Perhitungan Type: 
 - Ini bisa berada di ** Net Jumlah ** (yang adalah jumlah dari jumlah dasar).
 - ** Pada Row Sebelumnya Jumlah / Amount ** (untuk pajak kumulatif atau biaya). Jika Anda memilih opsi ini, pajak akan diterapkan sebagai persentase dari baris sebelumnya (dalam tabel pajak) jumlah atau total.
 - ** Aktual ** (seperti yang disebutkan).
 2. Akun Kepala: Account buku di mana pajak ini akan dipesan 
 3. Biaya Center: Jika pajak / biaya adalah penghasilan (seperti pengiriman) atau beban perlu dipesan terhadap Cost Center.
 4. Keterangan: Deskripsi pajak (yang akan dicetak dalam faktur / tanda kutip).
 5. Tarif: Tarif Pajak.
 6. Jumlah: Jumlah Pajak.
 7. Total: Total kumulatif ke titik ini.
 8. Entrikan Row: Jika berdasarkan ""Sebelumnya Row Jumlah"" Anda dapat memilih nomor baris yang akan diambil sebagai dasar untuk perhitungan ini (default adalah baris sebelumnya).
 9. Pertimbangkan Pajak atau Biaya untuk: Pada bagian ini Anda dapat menentukan apakah pajak / biaya hanya untuk penilaian (bukan bagian dari total) atau hanya total (tidak menambah nilai Stok Barang) atau keduanya.
 10. Menambah atau Dikurangi: Apakah Anda ingin menambah atau mengurangi pajak."
DocType: Homepage,Homepage,Homepage
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Pilih Dokter ...
DocType: Grant Application,Grant Application Details ,Berikan Rincian Aplikasi
DocType: Purchase Receipt Item,Recd Quantity,Qty Diterima
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Biaya Rekaman Dibuat - {0}
DocType: Asset Category Account,Asset Category Account,Aset Kategori Akun
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Tidak dapat menghasilkan lebih Stok Barang {0} daripada kuantitas Sales Order {1}
apps/erpnext/erpnext/stock/doctype/item/item.js +360,Select Attribute Values,Pilih Nilai Atribut
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +537,Stock Entry {0} is not submitted,Entri Persediaan {0} tidak terkirim
DocType: Payment Reconciliation,Bank / Cash Account,Bank / Rekening Kas
apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,Next Contact By cannot be same as the Lead Email Address,Dikontak Oleh berikut tidak bisa sama dengan Alamat Email Prospek
DocType: Tax Rule,Billing City,Kota Penagihan
DocType: Asset,Manual,panduan
DocType: Salary Component Account,Salary Component Account,Akun Komponen Gaji
DocType: Global Defaults,Hide Currency Symbol,Sembunyikan Mata Uang
apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informasi donor
apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","misalnya Bank, Kas, Kartu Kredit"
DocType: Lead Source,Source Name,sumber Nama
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Tekanan darah istirahat normal pada orang dewasa sekitar 120 mmHg sistolik, dan diastolik 80 mmHg, disingkat &quot;120/80 mmHg&quot;"
DocType: Journal Entry,Credit Note,Nota Kredit
DocType: Warranty Claim,Service Address,Alamat Layanan
DocType: Asset Maintenance Task,Calibration,Kalibrasi
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Mebel dan perlengkapan
DocType: Item,Manufacture,Pembuatan
apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Penyiapan Perusahaan
,Lab Test Report,Laporan Uji Lab
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Silakan Pengiriman Catatan terlebih dahulu
DocType: Student Applicant,Application Date,Tanggal Aplikasi
DocType: Salary Detail,Amount based on formula,Jumlah berdasarkan formula
DocType: Purchase Invoice,Currency and Price List,Mata Uang dan Daftar Harga
DocType: Opportunity,Customer / Lead Name,Nama Pelanggan / Prospek
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Izin Tanggal tidak disebutkan
apps/erpnext/erpnext/config/manufacturing.py +7,Production,Produksi
DocType: Guardian,Occupation,Pendudukan
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Row {0}: Tanggal awal harus sebelum Tanggal Akhir
DocType: Crop,Planting Area,Luas Tanam
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Total (Qty)
DocType: Installation Note Item,Installed Qty,Terpasang Qty
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Ini bisa jadi karena beberapa Alamat Email yang salah di
apps/erpnext/erpnext/utilities/user_progress.py +28,You added ,Anda menambahkan
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,pelatihan Hasil
DocType: Purchase Invoice,Is Paid,Telah dibayar
DocType: Salary Structure,Total Earning,Total Penghasilan
DocType: Purchase Receipt,Time at which materials were received,Waktu di mana bahan yang diterima
DocType: Products Settings,Products per Page,Produk per Halaman
DocType: Stock Ledger Entry,Outgoing Rate,Tingkat keluar
apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Cabang master organisasi.
apps/erpnext/erpnext/controllers/accounts_controller.py +312, or ,atau
DocType: Sales Order,Billing Status,Status Penagihan
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Laporkan Masalah
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Beban utilitas
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-ke atas
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Journal Entri {1} tidak memiliki akun {2} atau sudah cocok dengan voucher lain
DocType: Supplier Scorecard Criteria,Criteria Weight,Kriteria Berat
DocType: Buying Settings,Default Buying Price List,Standar Membeli Daftar Harga
DocType: Payroll Entry,Salary Slip Based on Timesheet,Slip Gaji Berdasarkan Daftar Absen
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43,Buying Rate,Tingkat pembelian
DocType: Notification Control,Sales Order Message,Pesan Nota Penjualan
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Set Nilai Default seperti Perusahaan, Mata Uang, Tahun Anggaran Current, dll"
DocType: Payment Entry,Payment Type,Jenis Pembayaran
apps/erpnext/erpnext/stock/doctype/batch/batch.py +160,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Silakan pilih Batch for Item {0}. Tidak dapat menemukan satu bets yang memenuhi persyaratan ini
DocType: Hub Category,Parent Category,Kategori Induk
DocType: Payroll Entry,Select Employees,Pilih Karyawan
DocType: Opportunity,Potential Sales Deal,Kesepakatan potensial Penjualan
DocType: Complaint,Complaints,Keluhan
DocType: Payment Entry,Cheque/Reference Date,Cek / Tanggal Referensi
DocType: Purchase Invoice,Total Taxes and Charges,Jumlah Pajak dan Biaya
DocType: Employee,Emergency Contact,Darurat Kontak
DocType: Bank Reconciliation Detail,Payment Entry,Masuk pembayaran
DocType: Item,Quality Parameters,Parameter Kualitas
,sales-browser,penjualan-browser
apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Buku besar
DocType: Patient Medical Record,PMR-,PMR-
DocType: Drug Prescription,Drug Code,Kode obat
DocType: Target Detail,Target  Amount,Target Jumlah
DocType: POS Profile,Print Format for Online,Format Cetak untuk Online
DocType: Shopping Cart Settings,Shopping Cart Settings,Pengaturan Keranjang Belanja
DocType: Journal Entry,Accounting Entries,Entri Akuntansi
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Gandakan entri. Silakan periksa Peraturan Otorisasi {0}
DocType: Journal Entry Account,Reference Due Date,Tanggal Jatuh Tempo Referensi
DocType: Purchase Order,Ref SQ,Ref SQ
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,dokumen tanda terima harus diserahkan
DocType: Purchase Invoice Item,Received Qty,Qty Diterima
DocType: Stock Entry Detail,Serial No / Batch,Serial No / Batch
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Tidak Dibayar dan tidak Terkirim
DocType: Product Bundle,Parent Item,Induk Stok Barang
DocType: Account,Account Type,Jenis Account
DocType: Delivery Note,DN-RET-,DN-RET-
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Tidak ada lembar waktu
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,Cuti Jenis {0} tidak dapat membawa-diteruskan
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Jadwal pemeliharaan tidak dihasilkan untuk semua item. Silahkan klik 'Menghasilkan Jadwal'
,To Produce,Untuk Menghasilkan
apps/erpnext/erpnext/config/hr.py +93,Payroll,Daftar gaji
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Untuk baris {0} di {1}. Untuk menyertakan {2} di tingkat Item, baris {3} juga harus disertakan"
apps/erpnext/erpnext/utilities/activation.py +101,Make User,membuat Pengguna
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikasi paket untuk pengiriman (untuk mencetak)
DocType: Bin,Reserved Quantity,Reserved Kuantitas
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Harap masukkan alamat email yang benar
DocType: Volunteer Skill,Volunteer Skill,Keterampilan Relawan
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +736,Please select an item in the cart,Harap pilih item di keranjang
DocType: Landed Cost Voucher,Purchase Receipt Items,Nota Penerimaan Produk
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Menyesuaikan Bentuk
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,tunggakan
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Penyusutan Jumlah selama periode tersebut
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,Template cacat tidak harus template default
DocType: Account,Income Account,Akun Penghasilan
DocType: Payment Request,Amount in customer's currency,Jumlah dalam mata uang pelanggan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +823,Delivery,Pengiriman
DocType: Volunteer,Weekdays,Hari kerja
DocType: Stock Reconciliation Item,Current Qty,Jumlah saat ini
DocType: Restaurant Menu,Restaurant Menu,Menu Restoran
apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Sebelumnya
DocType: Appraisal Goal,Key Responsibility Area,Key Responsibility area
apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Batch Student membantu Anda melacak kehadiran, penilaian dan biaya untuk siswa"
DocType: Payment Entry,Total Allocated Amount,Jumlah Total Dialokasikan
apps/erpnext/erpnext/setup/doctype/company/company.py +147,Set default inventory account for perpetual inventory,Tetapkan akun inventaris default untuk persediaan perpetual
DocType: Item Reorder,Material Request Type,Permintaan Jenis Bahan
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural Journal masuk untuk gaji dari {0} ke {1}
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Kirim Email Peninjauan Hibah
apps/erpnext/erpnext/accounts/page/pos/pos.js +840,"LocalStorage is full, did not save","LocalStorage penuh, tidak menyimpan"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +95,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM Faktor Konversi adalah wajib
apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Kapasitas Kamar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Biaya pendaftaran
DocType: Budget,Cost Center,Biaya Pusat
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,Voucher #,Voucher #
DocType: Notification Control,Purchase Order Message,Pesan Purchase Order
DocType: Tax Rule,Shipping Country,Pengiriman Negara
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Menyembunyikan Id Pajak Nasabah Transaksi Penjualan
DocType: Upload Attendance,Upload HTML,Unggah HTML
DocType: Employee,Relieving Date,Menghilangkan Tanggal
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Rule harga dibuat untuk menimpa Daftar Harga / mendefinisikan persentase diskon, berdasarkan beberapa kriteria."
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Gudang hanya dapat diubah melalui Entri Persediaan / Nota Pengiriman / Nota Pembelian
DocType: Employee Education,Class / Percentage,Kelas / Persentase
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Kepala Pemasaran dan Penjualan
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Pajak Penghasilan
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Jika Aturan Harga yang dipilih dibuat untuk 'Harga', itu akan menimpa Daftar Harga. Harga Rule harga adalah harga akhir, sehingga tidak ada diskon lebih lanjut harus diterapkan. Oleh karena itu, dalam transaksi seperti Sales Order, Purchase Order dll, maka akan diambil di lapangan 'Tingkat', daripada lapangan 'Daftar Harga Tingkat'."
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Lacak Prospek menurut Jenis Industri.
apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Pergi ke kop surat
DocType: Item Supplier,Item Supplier,Item Supplier
apps/erpnext/erpnext/public/js/controllers/transaction.js +1243,Please enter Item Code to get batch no,Entrikan Item Code untuk mendapatkan bets tidak
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +874,Please select a value for {0} quotation_to {1},Silakan pilih nilai untuk {0} quotation_to {1}
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Semua Alamat
DocType: Company,Stock Settings,Pengaturan Persediaan
apps/erpnext/erpnext/accounts/doctype/account/account.py +183,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Penggabungan ini hanya mungkin jika sifat berikut yang sama di kedua catatan. Apakah Group, Akar Jenis, Perusahaan"
DocType: Vehicle,Electric,listrik
DocType: Task,% Progress,% Selesai
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Laba / Rugi Asset Disposal
DocType: Task,Depends on Tasks,Tergantung pada Tugas
apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Kelola Pohon Kelompok Pelanggan.
DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Lampiran dapat ditunjukkan tanpa mengaktifkan keranjang belanja
DocType: Normal Test Items,Result Value,Nilai hasil
DocType: Supplier Quotation,SQTN-,SQTN-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Baru Nama Biaya Pusat
DocType: Leave Control Panel,Leave Control Panel,Cuti Control Panel
DocType: Project,Task Completion,tugas Penyelesaian
apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Tidak tersedia
DocType: Volunteer,Volunteer Skills,Keterampilan Relawan
DocType: Appraisal,HR User,HR Pengguna
DocType: Purchase Invoice,Taxes and Charges Deducted,Pajak dan Biaya Dikurangi
apps/erpnext/erpnext/hooks.py +142,Issues,Isu
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status harus menjadi salah satu {0}
DocType: Sales Invoice,Debit To,Debit Untuk
DocType: Restaurant Menu Item,Restaurant Menu Item,Item Menu Restoran
DocType: Delivery Note,Required only for sample item.,Diperlukan hanya untuk item sampel.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Jumlah Aktual Setelah Transaksi
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},Tidak ada slip gaji ditemukan antara {0} dan {1}
,Pending SO Items For Purchase Request,Pending SO Items Untuk Pembelian Permintaan
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Penerimaan Mahasiswa
apps/erpnext/erpnext/accounts/party.py +376,{0} {1} is disabled,{0} {1} dinonaktifkan
DocType: Supplier,Billing Currency,Mata Uang Penagihan
DocType: Sales Invoice,SINV-RET-,SINV-RET-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Ekstra Besar
DocType: Crop,Scientific Name,Nama ilmiah
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Jumlah Daun
DocType: Consultation,In print,Di cetak
,Profit and Loss Statement,Laba Rugi
DocType: Bank Reconciliation Detail,Cheque Number,Nomor Cek
,Sales Browser,Browser Penjualan
DocType: Journal Entry,Total Credit,Jumlah Kredit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +540,Warning: Another {0} # {1} exists against stock entry {2},Peringatan: Ada {0} # {1} lain terhadap entri persediaan {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,[Daerah
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Pinjaman Uang Muka dan (Aset)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Debitur
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Besar
DocType: Homepage Featured Product,Homepage Featured Product,Homepage Produk Pilihan
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +246,All Assessment Groups,Semua Grup Assessment
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Gudang baru Nama
apps/erpnext/erpnext/accounts/report/financial_statements.py +233,Total {0} ({1}),Total {0} ({1})
DocType: C-Form Invoice Detail,Territory,Wilayah
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Harap menyebutkan tidak ada kunjungan yang diperlukan
DocType: Stock Settings,Default Valuation Method,Metode Perhitungan Standar
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Biaya
apps/erpnext/erpnext/setup/doctype/company/company.js +154,Update in progress. It might take a while.,Perbaruan sedang berlangsung. Mungkin perlu beberapa saat.
DocType: Vehicle Log,Fuel Qty,BBM Qty
DocType: Production Order Operation,Planned Start Time,Rencana Start Time
DocType: Course,Assessment,Penilaian
DocType: Payment Entry Reference,Allocated,Dialokasikan
apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Tutup Neraca dan Perhitungan Laba Rugi atau buku.
DocType: Student Applicant,Application Status,Status aplikasi
DocType: Sensitivity Test Items,Sensitivity Test Items,Item Uji Sensitivitas
DocType: Fees,Fees,biaya
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Tentukan Nilai Tukar untuk mengkonversi satu mata uang ke yang lain
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Quotation {0} dibatalkan
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Jumlah Total Outstanding
DocType: Sales Partner,Targets,Target
DocType: Price List,Price List Master,Daftar Harga Guru
DocType: GST Account,CESS Account,Akun CESS
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Semua Transaksi Penjualan dapat ditandai terhadap beberapa ** Orang Penjualan ** sehingga Anda dapat mengatur dan memonitor target.
,S.O. No.,SO No
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Silakan membuat Pelanggan dari Prospek {0}
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Pilih pasien
DocType: Price List,Applicable for Countries,Berlaku untuk Negara
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Nama parameter
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Hanya Tinggalkan Aplikasi status &#39;Disetujui&#39; dan &#39;Ditolak&#39; dapat disampaikan
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Mahasiswa Nama Group adalah wajib berturut-turut {0}
DocType: Homepage,Products to be shown on website homepage,Produk yang akan ditampilkan pada homepage website
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Ini adalah kelompok pelanggan paling dasar dan tidak dapat diedit.
DocType: Student,AB-,AB-
DocType: POS Profile,Ignore Pricing Rule,Abaikan Aturan Harga
DocType: Employee Education,Graduate,Lulusan
DocType: Leave Block List,Block Days,Blok Hari
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Alamat Pengiriman tidak memiliki negara, yang diperlukan untuk Aturan Pengiriman ini"
DocType: Journal Entry,Excise Entry,Cukai Entri
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Peringatan: Order Penjualan {0} sudah ada untuk Order Pembelian Pelanggan {1}
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.","Syarat dan Ketentuan Standar yang dapat ditambahkan ke Penjualan dan Pembelian. Contoh : 1. Validitas tawaran. 1. Termin Pembayaran (Pembayaran Dimuka, Secara Kredit, pembayaran dimuka sebagian, dll). 1. Apa yang ekstra (atau dibayar oleh Pelanggan). 1. Peringatan keamanan / penggunaan. 1. Garansi jika ada. 1. Kebijakan Retur. 1. Syarat pengiriman, jika berlaku. 1. Cara menangani sengketa, ganti rugi, kewajiban, dll. 1. Alamat dan Kontak Perusahaan Anda."
DocType: Issue,Issue Type,Jenis Isu
DocType: Attendance,Leave Type,Cuti Type
DocType: Purchase Invoice,Supplier Invoice Details,Pemasok Rincian Faktur
DocType: Agriculture Task,Ignore holidays,Abaikan hari libur
apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Beban akun / Difference ({0}) harus akun 'Laba atau Rugi'
DocType: Project,Copied From,Disalin dari
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Nama error: {0}
apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Shortage,Kekurangan
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Kehadiran bagi karyawan {0} sudah ditandai
DocType: Packing Slip,If more than one package of the same type (for print),Jika lebih dari satu paket dari jenis yang sama (untuk mencetak)
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Harap tetapkan pelanggan default di Pengaturan Restoran
,Salary Register,Register Gaji
DocType: Warehouse,Parent Warehouse,Gudang tua
DocType: C-Form Invoice Detail,Net Total,Jumlah Bersih
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +527,Default BOM not found for Item {0} and Project {1},Default BOM tidak ditemukan untuk Item {0} dan Project {1}
apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Mendefinisikan berbagai jenis pinjaman
DocType: Bin,FCFS Rate,FCFS Tingkat
DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Jumlah belum terbayar
apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Waktu (dalam menit)
DocType: Project Task,Working,Kerja
DocType: Stock Ledger Entry,Stock Queue (FIFO),Antrian Persediaan (FIFO)
apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Tahun Keuangan
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} bukan milik Perusahaan {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,Tidak dapat memecahkan kriteria fungsi skor untuk {0}. Pastikan rumusnya benar.
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Biaya seperti pada
DocType: Healthcare Settings,Out Patient Settings,Keluar Pengaturan Pasien
DocType: Account,Round Off,Membulatkan
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +252,Quantity must be positive,Kuantitas harus positif
,Requested Qty,Diminta Qty
DocType: Tax Rule,Use for Shopping Cart,Gunakan untuk Keranjang Belanja
apps/erpnext/erpnext/controllers/item_variant.py +96,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Nilai {0} untuk Atribut {1} tidak ada dalam daftar Barang valid Atribut Nilai untuk Item {2}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Pilih Nomor Seri
DocType: BOM Item,Scrap %,Scrap%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Biaya akan didistribusikan secara proporsional berdasarkan pada item qty atau jumlah, sesuai pilihan Anda"
DocType: Maintenance Visit,Purposes,Tujuan
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Atleast satu item harus dimasukkan dengan kuantitas negatif dalam dokumen kembali
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operasi {0} lebih lama daripada jam kerja yang tersedia di workstation {1}, memecah operasi menjadi beberapa operasi"
DocType: Membership,Membership Status,Status Keanggotaan
,Requested,Diminta
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Tidak ada Keterangan
DocType: Asset,In Maintenance,Dalam perawatan
DocType: Purchase Invoice,Overdue,Terlambat
DocType: Account,Stock Received But Not Billed,Persediaan Diterima Tapi Tidak Ditagih
apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root Account must be a group,Akar Rekening harus kelompok
DocType: Consultation,Drug Prescription,Resep obat
DocType: Fees,FEE.,BIAYA.
DocType: Employee Loan,Repaid/Closed,Dilunasi / Ditutup
DocType: Item,Total Projected Qty,Total Proyeksi Jumlah
DocType: Monthly Distribution,Distribution Name,Nama Distribusi
apps/erpnext/erpnext/stock/stock_ledger.py +471,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Angka penilaian tidak ditemukan untuk Item {0}, yang diperlukan untuk melakukan entri akuntansi untuk {1} {2}. Jika item tersebut bertransaksi sebagai item angka penilaian nol di {1}, mohon sebutkan di tabel Item {1}. Jika tidak, buat transaksi saham masuk untuk item tersebut atau beri nilai valuasi dalam catatan Item, lalu coba kirimkan / batalkan entri ini."
DocType: Course,Course Code,Kode Course
apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},Inspeksi Mutu diperlukan untuk Item {0}
DocType: POS Settings,Use POS in Offline Mode,Gunakan POS dalam Mode Offline
DocType: Supplier Scorecard,Supplier Variables,Variabel pemasok
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Tingkat di mana mata uang pelanggan dikonversi ke mata uang dasar perusahaan
DocType: Purchase Invoice Item,Net Rate (Company Currency),Tingkat Net (Perusahaan Mata Uang)
DocType: Salary Detail,Condition and Formula Help,Kondisi dan Formula Bantuan
apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Kelola Wilayah Tree.
DocType: Journal Entry Account,Sales Invoice,Faktur Penjualan
DocType: Journal Entry Account,Party Balance,Saldo Partai
apps/erpnext/erpnext/accounts/page/pos/pos.js +498,Please select Apply Discount On,Silakan pilih Terapkan Diskon Pada
DocType: Stock Settings,Sample Retention Warehouse,Contoh Retensi Gudang
DocType: Company,Default Receivable Account,Standar Piutang Rekening
DocType: Physician,Physician Schedule,Jadwal dokter
DocType: Purchase Invoice,Deemed Export,Dianggap ekspor
DocType: Stock Entry,Material Transfer for Manufacture,Alih Material untuk Produksi
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Persentase Diskon dapat diterapkan baik terhadap Daftar Harga atau untuk semua List Price.
DocType: Subscription,Half-yearly,Setengah tahun sekali
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407,Accounting Entry for Stock,Entri Akuntansi untuk Persediaan
DocType: Lab Test,LabTest Approver,Pendekatan LabTest
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61,You have already assessed for the assessment criteria {}.,Anda telah memberikan penilaian terhadap kriteria penilaian {}.
DocType: Vehicle Service,Engine Oil,Oli mesin
DocType: Sales Invoice,Sales Team1,Penjualan team1
apps/erpnext/erpnext/stock/doctype/item/item.py +521,Item {0} does not exist,Item {0} tidak ada
DocType: Sales Invoice,Customer Address,Alamat Pelanggan
DocType: Employee Loan,Loan Details,Detail pinjaman
DocType: Company,Default Inventory Account,Akun Inventaris Default
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Row {0}: Selesai Qty harus lebih besar dari nol.
DocType: Antibiotic,Antibiotic Name,Nama Antibiotik
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Item Code&gt; Item Group&gt; Brand
DocType: Purchase Invoice,Apply Additional Discount On,Terapkan tambahan Diskon Pada
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Pilih Jenis ...
DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,Tautan ke semua Unit Tanah tempat Tanaman tumbuh
DocType: Account,Root Type,Akar Type
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Baris # {0}: Tidak dapat mengembalikan lebih dari {1} untuk Barang {2}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +45,Plot,Plot
DocType: Item Group,Show this slideshow at the top of the page,Tampilkan slide ini di bagian atas halaman
DocType: BOM,Item UOM,Stok Barang UOM
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Jumlah pajak Setelah Diskon Jumlah (Perusahaan Mata Uang)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +160,Target warehouse is mandatory for row {0},Target gudang adalah wajib untuk baris {0}
DocType: Cheque Print Template,Primary Settings,Pengaturan utama
DocType: Purchase Invoice,Select Supplier Address,Pilih Pemasok Alamat
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Tambahkan Karyawan
DocType: Purchase Invoice Item,Quality Inspection,Inspeksi Mutu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Ekstra Kecil
DocType: Company,Standard Template,Template standar
DocType: Training Event,Theory,Teori
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +805,Warning: Material Requested Qty is less than Minimum Order Qty,Peringatan: Material Diminta Qty kurang dari Minimum Order Qty
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Akun {0} dibekukan
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Badan Hukum / Anak dengan Bagan terpisah Account milik Organisasi.
DocType: Payment Request,Mute Email,Diamkan Surel
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Makanan, Minuman dan Tembakau"
DocType: Account,Account Number,Nomor Akun
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +714,Can only make payment against unbilled {0},Hanya dapat melakukan pembayaran terhadap yang belum ditagihkan {0}
apps/erpnext/erpnext/controllers/selling_controller.py +101,Commission rate cannot be greater than 100,Tingkat komisi tidak dapat lebih besar dari 100
DocType: Volunteer,Volunteer,Sukarelawan
DocType: Stock Entry,Subcontract,Kontrak tambahan
apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,Entrikan {0} terlebih dahulu
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +87,No replies from,Tidak ada balasan dari
DocType: Production Order Operation,Actual End Time,Waktu Akhir Aktual
DocType: Production Planning Tool,Download Materials Required,Unduh Kebutuhan Material
DocType: Item,Manufacturer Part Number,Produsen Part Number
DocType: Production Order Operation,Estimated Time and Cost,Perkiraan Waktu dan Biaya
DocType: Bin,Bin,Tong Sampah
DocType: Crop,Crop Name,Nama tanaman
DocType: SMS Log,No of Sent SMS,Tidak ada dari Sent SMS
DocType: Antibiotic,Healthcare Administrator,Administrator Kesehatan
apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Tetapkan Target
DocType: Dosage Strength,Dosage Strength,Kekuatan Dosis
DocType: Account,Expense Account,Beban Akun
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Perangkat lunak
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Warna
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteria Rencana Penilaian
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Cegah Pesanan Pembelian
apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,Rentan
DocType: Patient Appointment,Scheduled,Dijadwalkan
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Meminta kutipan.
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Silahkan pilih barang yang ""Barang Stok"" nya  ""Tidak"" dan ""Barang Jualan"" nya ""Ya"", serta tidak ada Bundel Produk lainnya"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Pilih pelanggan
DocType: Student Log,Academic,Akademis
DocType: Patient,Personal and Social History,Sejarah Pribadi dan Sosial
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +52,User {0} created,Pengguna {0} dibuat
DocType: Fee Schedule,Fee Breakup for each student,Fee Breakup untuk setiap siswa
apps/erpnext/erpnext/controllers/accounts_controller.py +540,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Total muka ({0}) terhadap Orde {1} tidak dapat lebih besar dari Grand Total ({2})
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Pilih Distribusi bulanan untuk merata mendistribusikan target di bulan.
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Ubah Kode
DocType: Purchase Invoice Item,Valuation Rate,Tingkat Penilaian
DocType: Stock Reconciliation,SR/,SR /
DocType: Vehicle,Diesel,disel
apps/erpnext/erpnext/stock/get_item_details.py +386,Price List Currency not selected,Daftar Harga Mata uang tidak dipilih
,Student Monthly Attendance Sheet,Mahasiswa Lembar Kehadiran Bulanan
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Aturan pengiriman hanya berlaku untuk penjualan
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Karyawan {0} telah diterapkan untuk {1} antara {2} dan {3}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Tanggal Project Mulai
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +5,Until,Sampai
DocType: Rename Tool,Rename Log,Log Riwayat Ganti Nama
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Student Group atau Jadwal Kursus adalah wajib
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Samakan Jam Penagihan dan Jam Kerja di Daftar Absen
DocType: Maintenance Visit Purpose,Against Document No,Terhadap No. Dokumen
DocType: BOM,Scrap,Membatalkan
apps/erpnext/erpnext/utilities/user_progress.py +214,Go to Instructors,Pergi ke instruktur
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Kelola Partner Penjualan
DocType: Quality Inspection,Inspection Type,Tipe Inspeksi
DocType: Fee Validity,Visited yet,Dikunjungi belum
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Gudang dengan transaksi yang ada tidak dapat dikonversi ke grup.
DocType: Assessment Result Tool,Result HTML,hasil HTML
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Memeber Activity,Aktivitas Memeber
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Kadaluarsa pada
apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Tambahkan Siswa
apps/erpnext/erpnext/public/js/utils.js +264,Please select {0},Silahkan pilih {0}
DocType: C-Form,C-Form No,C-Form ada
DocType: BOM,Exploded_items,Pembesaran Item
apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,Cantumkan produk atau layanan yang Anda beli atau jual.
DocType: Water Analysis,Storage Temperature,Suhu Penyimpanan
DocType: Employee Attendance Tool,Unmarked Attendance,Kehadiran non-absen
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Peneliti
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Pendaftaran Alat Mahasiswa
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Tanggal mulai harus kurang dari tanggal akhir untuk tugas {0}
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Nama atau Email adalah wajib
DocType: Instructor,Instructor Log,Log Instruktur
DocType: Purchase Order Item,Returned Qty,Qty Retur
DocType: Student,Exit,Keluar
apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Tipe Dasar adalah wajib
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Gagal memasang prasetel
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} saat ini memiliki {1} posisi Supplier Scorecard, dan RFQs ke pemasok ini harus dikeluarkan dengan hati-hati."
DocType: Chapter,Non Profit Manager,Manajer Non Profit
DocType: BOM,Total Cost(Company Currency),Total Biaya (Perusahaan Mata Uang)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,Serial ada {0} dibuat
DocType: Homepage,Company Description for website homepage,Deskripsi Perusahaan untuk homepage website
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Untuk kenyamanan pelanggan, kode ini dapat digunakan dalam format cetak seperti Faktur dan Nota Pengiriman"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,Nama suplier
apps/erpnext/erpnext/accounts/report/financial_statements.py +152,Could not retrieve information for {0}.,Tidak dapat mengambil informasi untuk {0}.
DocType: Sales Invoice,Time Sheet List,Waktu Daftar Lembar
DocType: Employee,You can enter any date manually,Anda dapat memasukkan tanggal apapun secara manual
DocType: Healthcare Settings,Result Printed,Hasil cetak
DocType: Asset Category Account,Depreciation Expense Account,Akun Beban Penyusutan
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Probationary Period,Masa percobaan
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Lihat {0}
DocType: Customer Group,Only leaf nodes are allowed in transaction,Hanya node cuti yang diperbolehkan dalam transaksi
DocType: Project,Total Costing Amount (via Timesheets),Total Costing Amount (melalui Timesheets)
DocType: Employee Advance,Expense Approver,Approver Klaim Biaya
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +134,Row {0}: Advance against Customer must be credit,Baris {0}: Uang muka dari Pelanggan harus kredit
apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Non-Group untuk Grup
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Batch wajib di baris {0}
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Nota Penerimaan Stok Barang Disediakan
DocType: Payment Entry,Pay,Membayar
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Untuk Datetime
apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Log untuk mempertahankan status pengiriman sms
DocType: Accounts Settings,Make Payment via Journal Entry,Lakukan Pembayaran via Journal Entri
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +97,Printed On,Printed On
DocType: Item,Inspection Required before Delivery,Inspeksi Diperlukan sebelum Pengiriman
DocType: Item,Inspection Required before Purchase,Inspeksi Diperlukan sebelum Pembelian
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Kegiatan Tertunda
DocType: Patient Appointment,Reminded,Mengingatkan
DocType: Patient,PID-,PID-
DocType: Chapter Member,Chapter Member,Bab Anggota
apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Organisasi Anda
DocType: Fee Component,Fees Category,biaya Kategori
apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Silahkan masukkan menghilangkan date.
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
DocType: Supplier Scorecard,Notify Employee,Beritahu Karyawan
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Entrikan nama kampanye jika sumber penyelidikan adalah kampanye
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Penerbit Koran
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Pilih Tahun Fiskal
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,Tanggal Pengiriman yang Diharapkan harus setelah Tanggal Pesanan Penjualan
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Tingkat Re-Order
DocType: Company,Chart Of Accounts Template,Grafik Of Account Template
DocType: Attendance,Attendance Date,Tanggal Kehadiran
apps/erpnext/erpnext/stock/get_item_details.py +350,Item Price updated for {0} in Price List {1},Harga Barang diperbarui untuk {0} di Daftar Harga {1}
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Gaji perpisahan berdasarkan Produktif dan Pengurangan.
apps/erpnext/erpnext/accounts/doctype/account/account.py +128,Account with child nodes cannot be converted to ledger,Akun dengan node anak tidak dapat dikonversi ke buku besar
DocType: Purchase Invoice Item,Accepted Warehouse,Gudang Barang Diterima
DocType: Bank Reconciliation Detail,Posting Date,Tanggal Posting
DocType: Item,Valuation Method,Metode Perhitungan
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Half Day
DocType: Sales Invoice,Sales Team,Tim Penjualan
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,Duplicate entry,Entri Ganda/Duplikat
DocType: Program Enrollment Tool,Get Students,Dapatkan Siswa
DocType: Serial No,Under Warranty,Masih Garansi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +515,[Error],[Kesalahan]
DocType: Sales Order,In Words will be visible once you save the Sales Order.,Dalam Kata-kata akan terlihat setelah Anda menyimpan Sales Order.
,Employee Birthday,Ulang Tahun Karyawan
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Silakan pilih Tanggal Penyelesaian untuk Perbaikan Selesai
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Alat Batch Kehadiran mahasiswa
apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,batas Dilalui
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Terjadwal Upto
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Modal Ventura
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Istilah akademik dengan ini &#39;Tahun Akademik&#39; {0} dan &#39;Nama Term&#39; {1} sudah ada. Harap memodifikasi entri ini dan coba lagi.
DocType: UOM,Must be Whole Number,Harus Nomor Utuh
DocType: Leave Control Panel,New Leaves Allocated (In Days),cuti baru Dialokasikan (Dalam Hari)
DocType: Purchase Invoice,Invoice Copy,Salinan faktur
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serial ada {0} tidak ada
DocType: Sales Invoice Item,Customer Warehouse (Optional),Gudang Customer (pilihan)
DocType: Pricing Rule,Discount Percentage,Persentase Diskon
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Dicadangkan untuk sub kontrak
DocType: Payment Reconciliation Invoice,Invoice Number,Nomor Faktur
DocType: Shopping Cart Settings,Orders,Order
DocType: Employee Leave Approver,Leave Approver,Approver Cuti
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,Silakan pilih satu batch
DocType: Assessment Group,Assessment Group Name,Nama penilaian Grup
DocType: Manufacturing Settings,Material Transferred for Manufacture,Bahan Ditransfer untuk Produksi
DocType: Expense Claim,"A user with ""Expense Approver"" role","Pengguna dengan peran ""Expense Approver"""
DocType: Landed Cost Item,Receipt Document Type,Dokumen penerimaan Type
DocType: Daily Work Summary Settings,Select Companies,Pilih perusahaan
,Issued Items Against Production Order,Tahun Produk Terhadap Orde Produksi
DocType: Antibiotic,Healthcare,Kesehatan
DocType: Target Detail,Target Detail,Sasaran Detil
apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Varian tunggal
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Semua Jobs
DocType: Sales Order,% of materials billed against this Sales Order,% Bahan ditagih terhadap Sales Order ini
DocType: Program Enrollment,Mode of Transportation,Cara Transportasi
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Periode Penutupan Entri
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Pilih Departemen ...
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Biaya Center dengan transaksi yang ada tidak dapat dikonversi ke grup
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +361,Amount {0} {1} {2} {3},Jumlah {0} {1} {2} {3}
DocType: Account,Depreciation,Penyusutan
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Supplier (s)
DocType: Employee Attendance Tool,Employee Attendance Tool,Alat Absensi Karyawan
DocType: Guardian Student,Guardian Student,wali Mahasiswa
DocType: Supplier,Credit Limit,Batas Kredit
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Rata-rata Tarif Daftar Harga Jual
DocType: Production Plan Sales Order,Salse Order Date,Salse Urutan Tanggal
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Supplier&gt; Supplier Type
DocType: Salary Component,Salary Component,Komponen gaji
apps/erpnext/erpnext/accounts/utils.py +495,Payment Entries {0} are un-linked,Entries pembayaran {0} adalah un-linked
DocType: GL Entry,Voucher No,Voucher Tidak ada
,Lead Owner Efficiency,Efisiensi Pemilik Prospek
apps/erpnext/erpnext/hub_node/page/hub/hub.js +195,Most Popular,Paling populer
DocType: Leave Allocation,Leave Allocation,Alokasi Cuti
DocType: Payment Request,Recipient Message And Payment Details,Penerima Pesan Dan Rincian Pembayaran
DocType: Training Event,Trainer Email,Email Pelatih
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Permintaan Material {0} dibuat
DocType: Restaurant Reservation,No of People,Tidak ada orang
DocType: Production Planning Tool,Include sub-contracted raw materials,Termasuk bahan baku sub-kontrak
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Template istilah atau kontrak.
DocType: Purchase Invoice,Address and Contact,Alamat dan Kontak
DocType: Cheque Print Template,Is Account Payable,Apakah Account Payable
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Persediaan tidak dapat diperbarui terhadap Nota Pembelian {0}
DocType: Company,Last Day of the Next Month,Hari terakhir dari Bulan Depan
DocType: Support Settings,Auto close Issue after 7 days,Auto Issue dekat setelah 7 hari
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Cuti tidak dapat dialokasikan sebelum {0}, saldo cuti sudah pernah membawa-diteruskan dalam catatan alokasi cuti masa depan {1}"
apps/erpnext/erpnext/accounts/party.py +320,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Catatan: Tanggal Jatuh Tempo / Referensi melebihi {0} hari dari yang diperbolehkan untuk kredit pelanggan
apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,Mahasiswa Pemohon
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL UNTUK RECIPIENT
DocType: Asset Category Account,Accumulated Depreciation Account,Akun Penyusutan Akumulasi
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Email ini otomatis terkirim
DocType: Stock Settings,Freeze Stock Entries,Bekukan Entri Persediaan
DocType: Program Enrollment,Boarding Student,Siswa Asrama
DocType: Asset,Expected Value After Useful Life,Nilai diharapkan Setelah Hidup Berguna
DocType: Item,Reorder level based on Warehouse,Tingkat Re-Order berdasarkan Gudang
DocType: Activity Cost,Billing Rate,Tarip penagihan
,Qty to Deliver,Kuantitas Pengiriman
,Stock Analytics,Analisis Persediaan
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +508,Operations cannot be left blank,Operasi tidak dapat dibiarkan kosong
DocType: Maintenance Visit Purpose,Against Document Detail No,Terhadap Detail Dokumen No.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +99,Party Type is mandatory,Partai Type adalah wajib
DocType: Quality Inspection,Outgoing,Keluaran
DocType: Material Request,Requested For,Diminta Untuk
DocType: Quotation Item,Against Doctype,Terhadap Doctype
apps/erpnext/erpnext/controllers/buying_controller.py +414,{0} {1} is cancelled or closed,{0} {1} dibatalkan atau ditutup
DocType: Asset,Calculate Depreciation,Hitung Depresiasi
DocType: Delivery Note,Track this Delivery Note against any Project,Lacak Pengiriman ini Catatan terhadap Proyek manapun
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Kas Bersih dari Investasi
DocType: Production Order,Work-in-Progress Warehouse,Gudang Work In Progress
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Aset {0} harus diserahkan
DocType: Fee Schedule Program,Total Students,Jumlah Siswa
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Kehadiran Rekam {0} ada terhadap Mahasiswa {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +352,Reference #{0} dated {1},Referensi # {0} tanggal {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Penyusutan Dieliminasi karena pelepasan aset
DocType: Member,Member,Anggota
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Pengelolaan Alamat
DocType: Pricing Rule,Item Code,Kode Item
DocType: Production Planning Tool,Create Production Orders,Buat Order Produksi
DocType: Serial No,Warranty / AMC Details,Garansi / Detail AMC
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Pilih siswa secara manual untuk Activity based Group
DocType: Journal Entry,User Remark,Keterangan Pengguna
DocType: Lead,Market Segment,Segmen Pasar
DocType: Agriculture Analysis Criteria,Agriculture Manager,Manajer Pertanian
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},Dibayar Jumlah tidak dapat lebih besar dari jumlah total outstanding negatif {0}
DocType: Supplier Scorecard Period,Variables,Variabel
DocType: Employee Internal Work History,Employee Internal Work History,Riwayat Kerja Karyawan Internal
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Dr),Penutup (Dr)
DocType: Cheque Print Template,Cheque Size,Cek Ukuran
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,No. Seri {0} tidak tersedia
apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Template Pajak transaksi penjualan
DocType: Sales Invoice,Write Off Outstanding Amount,Write Off Jumlah Outstanding
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Akun {0} tidak sesuai Perusahaan {1}
DocType: Education Settings,Current Academic Year,Tahun Akademik Saat Ini
DocType: Stock Settings,Default Stock UOM,UOM Persediaan Standar
DocType: Asset,Number of Depreciations Booked,Jumlah Penyusutan Dipesan
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Terhadap Pinjaman Karyawan: {0}
DocType: Landed Cost Item,Receipt Document,Dokumen penerimaan
DocType: Production Planning Tool,Create Material Requests,Buat Order Permintaan Material
DocType: Employee Education,School/University,Sekolah / Universitas
DocType: Payment Request,Reference Details,Detail referensi
apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Expected Value After Useful Life must be less than Gross Purchase Amount,Nilai diharapkan Setelah Hidup Berguna harus kurang dari Gross Jumlah Pembelian
DocType: Sales Invoice Item,Available Qty at Warehouse,Jumlah Tersedia di Gudang
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Nilai Tagihan
DocType: Asset,Double Declining Balance,Ganda Saldo Menurun
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Agar tertutup tidak dapat dibatalkan. Unclose untuk membatalkan.
DocType: Student Guardian,Father,Ayah
apps/erpnext/erpnext/controllers/accounts_controller.py +626,'Update Stock' cannot be checked for fixed asset sale,'Pembaruan Persediaan’ tidak dapat ditandai untuk penjualan aset tetap
DocType: Bank Reconciliation,Bank Reconciliation,Rekonsiliasi Bank
DocType: Attendance,On Leave,Sedang cuti
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Dapatkan Perbaruan
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Akun {2} bukan milik Perusahaan {3}
apps/erpnext/erpnext/stock/doctype/item/item.js +366,Select at least one value from each of the attributes.,Pilih setidaknya satu nilai dari masing-masing atribut.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +162,Material Request {0} is cancelled or stopped,Permintaan Material {0} dibatalkan atau dihentikan
apps/erpnext/erpnext/config/hr.py +310,Leave Management,Manajemen Cuti
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Group by Akun
DocType: Sales Order,Fully Delivered,Sepenuhnya Terkirim
DocType: Lead,Lower Income,Penghasilan rendah
DocType: Restaurant Order Entry,Current Order,Pesanan saat ini
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +179,Source and target warehouse cannot be same for row {0},Sumber dan target gudang tidak bisa sama untuk baris {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Akun Perbedaan harus jenis rekening Aset / Kewajiban, karena Rekonsiliasi Persediaan adalah Entri Pembukaan"
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Dicairkan Jumlah tidak dapat lebih besar dari Jumlah Pinjaman {0}
apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Buka Program
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Baris {0} # Jumlah alokasi {1} tidak boleh lebih besar dari jumlah yang tidak diklaim {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Nomor Purchase Order yang diperlukan untuk Item {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +943,Production Order not created,Pesanan produksi tidak diciptakan
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date','Tanggal Mulai' harus sebelum 'Tanggal Akhir'
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},tidak dapat mengubah status sebagai mahasiswa {0} terkait dengan aplikasi mahasiswa {1}
DocType: Asset,Fully Depreciated,sepenuhnya disusutkan
,Stock Projected Qty,Proyeksi Jumlah Persediaan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +431,Customer {0} does not belong to project {1},Pelanggan {0} tidak termasuk proyek {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Kehadiran ditandai HTML
apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Penawaran adalah proposal, tawaran yang anda kirim kepada pelanggan"
DocType: Sales Order,Customer's Purchase Order,Order Pembelian Pelanggan
DocType: Consultation,Patient,Sabar
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Cek kredit bypass di Sales Order
DocType: Land Unit,Check if it is a hydroponic unit,Periksa apakah itu unit hidroponik
apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,Serial dan Batch
DocType: Warranty Claim,From Company,Dari Perusahaan
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52,Sum of Scores of Assessment Criteria needs to be {0}.,Jumlah Skor Kriteria Penilaian perlu {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Silakan mengatur Jumlah Penyusutan Dipesan
DocType: Supplier Scorecard Period,Calculations,Perhitungan
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Nilai atau Qty
DocType: Payment Terms Template,Payment Terms,Syarat pembayaran
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +426,Productions Orders cannot be raised for:,Produksi Pesanan tidak dapat diangkat untuk:
apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Menit
DocType: Purchase Invoice,Purchase Taxes and Charges,Pajak Pembelian dan Biaya
DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Pergi ke Pemasok
,Qty to Receive,Kuantitas untuk diterima
DocType: Leave Block List,Leave Block List Allowed,Cuti Block List Diizinkan
DocType: Grading Scale Interval,Grading Scale Interval,Grading Scale Interval
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Beban Klaim untuk Kendaraan Log {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Discount (%) pada Price List Rate dengan Margin
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,semua Gudang
DocType: Sales Partner,Retailer,Pengecer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Kredit Untuk akun harus rekening Neraca
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Semua Jenis Supplier
DocType: Donor,Donor,Penyumbang
DocType: Global Defaults,Disable In Words,Nonaktifkan Dalam Kata-kata
apps/erpnext/erpnext/stock/doctype/item/item.py +49,Item Code is mandatory because Item is not automatically numbered,Item Code adalah wajib karena Item tidak secara otomatis nomor
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Penawaran {0} bukan jenis {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Jadwal pemeliharaan Stok Barang
DocType: Sales Order,%  Delivered,% Terkirim
apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,Harap atur ID Email untuk Siswa untuk mengirim Permintaan Pembayaran
DocType: Production Order,PRO-,PRO-
DocType: Patient,Medical History,Riwayat kesehatan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Akun Overdraft Bank
DocType: Patient,Patient ID,ID pasien
DocType: Physician Schedule,Schedule Name,Nama Jadwal
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Membuat Slip Gaji
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +838,Add All Suppliers,Tambahkan Semua Pemasok
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +83,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Baris # {0}: Alokasi Jumlah tidak boleh lebih besar dari jumlah yang terutang.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Telusuri BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Pinjaman Aman
DocType: Purchase Invoice,Edit Posting Date and Time,Mengedit Posting Tanggal dan Waktu
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Silahkan mengatur Penyusutan Akun terkait Aset Kategori {0} atau Perusahaan {1}
DocType: Lab Test Groups,Normal Range,Jarak normal
DocType: Academic Term,Academic Year,Tahun akademik
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Jual Beli
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Saldo Pembukaan Ekuitas
DocType: Lead,CRM,CRM
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,sisa
DocType: Appraisal,Appraisal,Penilaian
DocType: Purchase Invoice,GST Details,Rincian GST
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},Email dikirim ke pemasok {0}
DocType: Item,Default Sales Unit of Measure,Unit Penjualan Default Ukur
DocType: Opportunity,OPTY-,OPTY-
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Tanggal diulang
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Penandatangan yang Sah
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},Cuti approver harus menjadi salah satu {0}
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Buat Biaya
DocType: Project,Total Purchase Cost (via Purchase Invoice),Total Biaya Pembelian (Purchase Invoice via)
DocType: Training Event,Start Time,Waktu Mulai
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +400,Select Quantity,Pilih Kuantitas
DocType: Customs Tariff Number,Customs Tariff Number,Tarif Bea Nomor
DocType: Patient Appointment,Patient Appointment,Penunjukan Pasien
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Menyetujui Peran tidak bisa sama dengan peran aturan yang Berlaku Untuk
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Berhenti berlangganan dari Email Ringkasan ini
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +828,Get Suppliers By,Dapatkan Pemasok Dengan
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{0} tidak ditemukan untuk Barang {1}
apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Pergi ke kursus
DocType: Accounts Settings,Show Inclusive Tax In Print,Menunjukkan Pajak Inklusif Dalam Cetak
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Pesan Terkirim
apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Account with child nodes cannot be set as ledger,Akun dengan sub-akun tidak dapat digunakan sebagai akun buku besar
DocType: C-Form,II,II
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Tingkat di mana mata uang Daftar Harga dikonversi ke mata uang dasar pelanggan
DocType: Purchase Invoice Item,Net Amount (Company Currency),Jumlah Bersih (Perusahaan Mata Uang)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +229,Total advance amount cannot be greater than total sanctioned amount,Jumlah uang muka tidak boleh lebih besar dari jumlah sanksi
DocType: Salary Slip,Hour Rate,Nilai per Jam
DocType: Stock Settings,Item Naming By,Item Penamaan Dengan
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Lain Periode Pendaftaran penutupan {0} telah dibuat setelah {1}
DocType: Production Order,Material Transferred for Manufacturing,Bahan Ditransfer untuk Manufaktur
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +37,Account {0} does not exists,Akun {0} tidak ada
DocType: Project,Project Type,Jenis proyek
apps/erpnext/erpnext/projects/doctype/task/task.py +142,Child Task exists for this Task. You can not delete this Task.,Tugas Anak ada untuk Tugas ini. Anda tidak dapat menghapus tugas ini.
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/hub_node/page/hub/hub.js +731,No more results,Tidak ada hasil lagi
apps/erpnext/erpnext/config/projects.py +51,Cost of various activities,Biaya berbagai kegiatan
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Mengatur Acara untuk {0}, karena karyawan yang melekat di bawah Penjualan Orang tidak memiliki User ID {1}"
DocType: Timesheet,Billing Details,Detail penagihan
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +155,Source and target warehouse must be different,Sumber dan gudang target harus berbeda
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Tidak diizinkan memperbarui transaksi persediaan lebih lama dari {0}
DocType: Purchase Invoice Item,PR Detail,PR Detil
DocType: Driving License Category,Class,Kelas
DocType: Sales Order,Fully Billed,Sepenuhnya Ditagih
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Aturan pengiriman hanya berlaku untuk pembelian
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Cash In Hand
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Gudang pengiriman diperlukan untuk persediaan barang {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Berat kotor paket. Berat + kemasan biasanya net berat bahan. (Untuk mencetak)
DocType: Assessment Plan,Program,Program
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Pengguna dengan peran ini diperbolehkan untuk mengatur account beku dan membuat / memodifikasi entri akuntansi terhadap rekening beku
DocType: Serial No,Is Cancelled,Apakah Dibatalkan
DocType: Student Group,Group Based On,Grup Berdasarkan
DocType: Journal Entry,Bill Date,Tanggal Penagihan
DocType: Healthcare Settings,Laboratory SMS Alerts,SMS Pemberitahuan Laboratorium
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Layanan Item, Jenis, frekuensi dan jumlah beban yang diperlukan"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Bahkan jika ada beberapa Aturan Harga dengan prioritas tertinggi, kemudian mengikuti prioritas internal diterapkan:"
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kriteria Analisis Tanaman
DocType: Cheque Print Template,Cheque Height,Cek Tinggi
DocType: Supplier,Supplier Details,Rincian Supplier
DocType: Setup Progress,Setup Progress,Setup Progress
DocType: Expense Claim,Approval Status,Approval Status
DocType: Hub Settings,Publish Items to Hub,Publikasikan Produk untuk Hub
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Dari nilai harus kurang dari nilai dalam baris {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,Transfer Kliring
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Periksa Semua
DocType: Vehicle Log,Invoice Ref,faktur Ref
DocType: Company,Default Income Account,Akun Pendapatan standar
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Kelompok Pelanggan / Pelanggan
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Tertutup Fiskal Tahun Laba / Rugi (Kredit)
DocType: Sales Invoice,Time Sheets,waktu Lembar
DocType: Lab Test Template,Change In Item,Ubah Item
DocType: Payment Gateway Account,Default Payment Request Message,Standar Pesan Permintaan Pembayaran
DocType: Item Group,Check this if you want to show in website,Periksa ini jika Anda ingin menunjukkan di website
apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Perbankan dan Pembayaran
,Welcome to ERPNext,Selamat Datang di ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Prospek menuju Penawaran
DocType: Patient,A Negative,Negatif
apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Tidak lebih untuk ditampilkan.
DocType: Lead,From Customer,Dari Pelanggan
apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Panggilan
apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Produk
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,Batches
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Jadikan Jadwal Biaya
DocType: Purchase Order Item Supplied,Stock UOM,UOM Persediaan
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Order Pembelian {0} tidak terkirim
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Rentang referensi normal untuk orang dewasa adalah 16-20 napas / menit (RCP 2012)
DocType: Customs Tariff Number,Tariff Number,tarif Nomor
DocType: Production Order Item,Available Qty at WIP Warehouse,Tersedia Qty di WIP Warehouse
apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,Proyeksi
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} does not belong to Warehouse {1},Serial ada {0} bukan milik Gudang {1}
apps/erpnext/erpnext/controllers/status_updater.py +174,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
DocType: Notification Control,Quotation Message,Pesan Penawaran
DocType: Employee Loan,Employee Loan Application,Karyawan Aplikasi Kredit
DocType: Issue,Opening Date,Tanggal Pembukaan
apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Kehadiran telah ditandai berhasil.
DocType: Program Enrollment,Public Transport,Transportasi umum
DocType: Soil Texture,Silt Composition (%),Komposisi Silt (%)
DocType: Journal Entry,Remark,Komentar
DocType: Healthcare Settings,Avoid Confirmation,Hindari Konfirmasi
DocType: Purchase Receipt Item,Rate and Amount,Rate dan Jumlah
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +165,Account Type for {0} must be {1},Jenis Akun untuk {0} harus {1}
DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Akun pendapatan default yang akan digunakan jika tidak ditetapkan dalam Dokter untuk memesan biaya Konsultasi.
apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Daun dan Liburan
DocType: Education Settings,Current Academic Term,Istilah Akademik Saat Ini
DocType: Sales Order,Not Billed,Tidak Ditagih
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Kedua Gudang harus merupakan gudang dari Perusahaan yang sama
apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Tidak ada kontak belum ditambahkan.
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Jumlah Nilai Voucher Landing Cost
apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Tagihan diajukan oleh Pemasok.
DocType: POS Profile,Write Off Account,Akun Write Off
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Debit Note Amt,Catatan Debet Amt
apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Jumlah Diskon
DocType: Purchase Invoice,Return Against Purchase Invoice,Retur Terhadap Faktur Pembelian
DocType: Item,Warranty Period (in days),Masa Garansi (dalam hari)
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Gagal menetapkan default
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Hubungan dengan Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +797,Please select BOM against item {0},Silahkan pilih BOM terhadap item {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Buat Faktur
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Kas Bersih dari Operasi
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Item 4
DocType: Student Admission,Admission End Date,Pendaftaran Tanggal Akhir
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Sub-kontraktor
DocType: Journal Entry Account,Journal Entry Account,Akun Jurnal Entri
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Kelompok mahasiswa
DocType: Shopping Cart Settings,Quotation Series,Seri Penawaran
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +56,"An item exists with same name ({0}), please change the item group name or rename the item","Sebuah item yang ada dengan nama yang sama ({0}), silakan mengubah nama kelompok Stok Barang atau mengubah nama item"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriteria Analisis Tanah
apps/erpnext/erpnext/accounts/page/pos/pos.js +2021,Please select customer,Silakan pilih pelanggan
DocType: C-Form,I,saya
DocType: Company,Asset Depreciation Cost Center,Asset Pusat Penyusutan Biaya
DocType: Sales Order Item,Sales Order Date,Tanggal Nota Penjualan
DocType: Sales Invoice Item,Delivered Qty,Qty Terkirim
DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Jika dicentang, semua anak-anak dari setiap item produksi akan dimasukkan dalam Permintaan Material."
DocType: Assessment Plan,Assessment Plan,Rencana penilaian
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Pelanggan {0} dibuat
DocType: Stock Settings,Limit Percent,batas Persen
apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Silakan setup Sistem Penamaan Instruktur di Pendidikan&gt; Pengaturan Pendidikan
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Saat ini tidak ada persediaan di gudang manapun
,Payment Period Based On Invoice Date,Masa Pembayaran Berdasarkan Faktur Tanggal
DocType: Sample Collection,No. of print,Jumlah cetak
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Hilang Kurs mata uang Tarif untuk {0}
DocType: Assessment Plan,Examiner,Pemeriksa
DocType: Student,Siblings,saudara
DocType: Journal Entry,Stock Entry,Entri Persediaan
DocType: Payment Entry,Payment References,Referensi pembayaran
DocType: C-Form,C-FORM-,C-bentuk-
DocType: Vehicle,Insurance Details,Detail asuransi
DocType: Account,Payable,Hutang
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Masukkan Periode Pembayaran
apps/erpnext/erpnext/shopping_cart/cart.py +375,Debtors ({0}),Debitur ({0})
DocType: Pricing Rule,Margin,Margin
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Pelanggan baru
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Gross Profit %,Laba Kotor%
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +496,Change POS Profile,Ubah Profil POS
DocType: Bank Reconciliation Detail,Clearance Date,Izin Tanggal
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Laporan Penilaian
apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Gross Purchase Amount is mandatory,Jumlah Pembelian kotor adalah wajib
DocType: Lead,Address Desc,Deskripsi Alamat
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +102,Party is mandatory,Partai adalah wajib
DocType: Journal Entry,JV-,JV-
apps/erpnext/erpnext/controllers/accounts_controller.py +707,Rows with duplicate due dates in other rows were found: {list},Baris dengan tanggal jatuh tempo duplikat pada baris lainnya ditemukan: {list}
DocType: Topic,Topic Name,topik Nama
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,"Setidaknya salah satu, Jual atau Beli harus dipilih"
apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Pilih jenis bisnis anda.
DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
<br>
Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
<br>
Descriptive for tests which have multiple result components and corresponding result entry fields. 
<br>
Grouped for test templates which are a group of other test templates.
<br>
No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Single untuk hasil yang hanya memerlukan satu input saja, hasil UOM dan nilai normal <br> Senyawa untuk hasil yang membutuhkan banyak field masukan dengan nama acara yang sesuai, hasil UOM dan nilai normal <br> Deskriptif untuk tes yang memiliki beberapa komponen hasil dan bidang entri hasil yang sesuai. <br> Dikelompokkan untuk template uji yang merupakan kelompok dari template uji lainnya. <br> Tidak ada hasil untuk tes tanpa hasil. Juga, tidak ada Lab Test yang dibuat. misalnya. Sub Tes untuk hasil yang dikelompokkan."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +75,Row #{0}: Duplicate entry in References {1} {2},Baris # {0}: Entri duplikat di Referensi {1} {2}
apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Dimana operasi manufaktur dilakukan.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,Sebagai pemeriksa
DocType: Asset Movement,Source Warehouse,Sumber Gudang
DocType: Installation Note,Installation Date,Instalasi Tanggal
apps/erpnext/erpnext/controllers/accounts_controller.py +605,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Aset {1} bukan milik perusahaan {2}
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Faktur Penjualan {0} dibuat
DocType: Employee,Confirmation Date,Konfirmasi Tanggal
DocType: C-Form,Total Invoiced Amount,Jumlah Total Tagihan
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,Min Qty tidak dapat lebih besar dari Max Qty
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Account,Accumulated Depreciation,Akumulasi penyusutan
DocType: Supplier Scorecard Scoring Standing,Standing Name,Nama berdiri
DocType: Stock Entry,Customer or Supplier Details,Rincian Pelanggan atau Pemasok
DocType: Employee Loan Application,Required by Date,Dibutuhkan oleh Tanggal
DocType: Lead,Lead Owner,Pemilik Prospek
DocType: Bin,Requested Quantity,diminta Kuantitas
DocType: Patient,Marital Status,Status Perkawinan
DocType: Stock Settings,Auto Material Request,Permintaan Material Otomatis
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Tersedia Batch Qty di Gudang Dari
DocType: Customer,CUST-,CUST-
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Pay Gross - Jumlah Pengurangan - Pelunasan Pinjaman
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +26,Current BOM and New BOM can not be same,BOM Lancar dan New BOM tidak bisa sama
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +45,Salary Slip ID,Slip Gaji ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,Tanggal Of Pensiun harus lebih besar dari Tanggal Bergabung
apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Beberapa varian
DocType: Sales Invoice,Against Income Account,Terhadap Akun Pendapatan
apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Terkirim
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +103,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Item {0}: qty Memerintahkan {1} tidak bisa kurang dari qty minimum order {2} (didefinisikan dalam Butir).
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Bulanan Persentase Distribusi
apps/erpnext/erpnext/hub_node/page/hub/hub.js +90,Please login as another user.,Silahkan login sebagai pengguna lain.
DocType: Territory,Territory Targets,Target Wilayah
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Delivery Note,Transporter Info,Info Transporter
apps/erpnext/erpnext/accounts/utils.py +502,Please set default {0} in Company {1},Silahkan mengatur default {0} di Perusahaan {1}
DocType: Cheque Print Template,Starting position from top edge,Mulai posisi dari tepi atas
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +31,Same supplier has been entered multiple times,pemasok yang sama telah dimasukkan beberapa kali
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Laba Kotor / Rugi
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Purchase Order Stok Barang Disediakan
apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Nama perusahaan tidak dapat perusahaan
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Surat Kepala untuk mencetak template.
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Judul untuk mencetak template misalnya Proforma Invoice.
DocType: Program Enrollment,Walking,Berjalan
DocType: Student Guardian,Student Guardian,Wali murid
DocType: Member,Member Name,Nama anggota
DocType: Stock Settings,Use Naming Series,Gunakan Seri Penamaan
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Jenis penilaian biaya tidak dapat ditandai sebagai Inklusif
DocType: POS Profile,Update Stock,Perbarui Persediaan
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,dalam berlangganan
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,UOM berbeda akan menyebabkan kesalahan Berat Bersih (Total). Pastikan Berat Bersih untuk setiap barang memakai UOM yang sama.
DocType: Membership,Payment Details,Rincian Pembayaran
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,Tingkat BOM
DocType: Asset,Journal Entry for Scrap,Jurnal masuk untuk Scrap
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Silakan tarik item dari Pengiriman Note
apps/erpnext/erpnext/accounts/utils.py +472,Journal Entries {0} are un-linked,Entri jurnal {0} un-linked
apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Catatan dari semua komunikasi email, telepon, chatting, kunjungan, dll"
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Penilai Scorecard Penilai Berdiri
DocType: Manufacturer,Manufacturers used in Items,Produsen yang digunakan dalam Produk
apps/erpnext/erpnext/accounts/general_ledger.py +168,Please mention Round Off Cost Center in Company,Sebutkan Putaran Off Biaya Pusat di Perusahaan
DocType: Purchase Invoice,Terms,Istilah
DocType: Academic Term,Term Name,istilah Nama
DocType: Buying Settings,Purchase Order Required,Order Pembelian Diperlukan
,Item-wise Sales History,Item-wise Penjualan Sejarah
DocType: Expense Claim,Total Sanctioned Amount,Jumlah Total Disahkan
DocType: Land Unit,Land Unit,Unit tanah
,Purchase Analytics,Pembelian Analytics
DocType: Sales Invoice Item,Delivery Note Item,Pengiriman Stok Barang Note
DocType: Asset Maintenance Log,Task,Tugas
DocType: Purchase Taxes and Charges,Reference Row #,Referensi Row #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Nomor kumpulan adalah wajib untuk Barang {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Ini adalah orang penjualan akar dan tidak dapat diedit.
DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Jika dipilih, nilai yang ditentukan atau dihitung dalam komponen ini tidak akan berkontribusi pada pendapatan atau deduksi. Namun, nilai itu bisa direferensikan oleh komponen lain yang bisa ditambah atau dikurangkan."
,Stock Ledger,Buku Persediaan
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Tingkat: {0}
DocType: Company,Exchange Gain / Loss Account,Efek Gain / Loss Akun
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Karyawan dan Kehadiran
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Purpose must be one of {0},Tujuan harus menjadi salah satu {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +116,Fill the form and save it,Isi formulir dan menyimpannya
DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,Unduh laporan yang berisi semua bahan baku dengan status persediaan terbarunya
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum Komunitas
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Jumlah persediaan aktual
DocType: Homepage,"URL for ""All Products""",URL untuk &quot;Semua Produk&quot;
DocType: Leave Application,Leave Balance Before Application,Cuti Saldo Sebelum Aplikasi
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46,Send SMS,Kirim SMS
DocType: Supplier Scorecard Criteria,Max Score,Skor Maks
DocType: Cheque Print Template,Width of amount in word,Lebar jumlah dalam kata
DocType: Company,Default Letter Head,Standar Surat Kepala
DocType: Purchase Order,Get Items from Open Material Requests,Dapatkan Produk dari Permintaan Buka Material
DocType: Lab Test Template,Standard Selling Rate,Standard Jual Tingkat
DocType: Account,Rate at which this tax is applied,Tingkat di mana pajak ini diterapkan
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +75,Reorder Qty,Susun ulang Qty
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Job Openings saat
DocType: Company,Stock Adjustment Account,Penyesuaian Akun Persediaan
apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Mencoret
DocType: Timesheet Detail,Operation ID,ID Operasi
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","Pengguna Sistem (login) ID. Jika diset, itu akan menjadi default untuk semua bentuk HR."
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Dari {1}
DocType: Task,depends_on,tergantung pada
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +49,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,"Diantrikan untuk memperbaharui harga terakhir di ""Bill of Material"". Akan memakan waktu beberapa menit."
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Nama Akun baru. Catatan: Jangan membuat akun untuk Pelanggan dan Pemasok
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Negara bijaksana Alamat bawaan Template
DocType: Water Analysis,Appearance,Penampilan
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Rata-rata Tarif Daftar Harga Beli
DocType: Sales Order Item,Supplier delivers to Customer,Pemasok mengirim ke Pelanggan
apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Informasi anggota
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (#Formulir/Barang/{0}) tidak tersedia
apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Pemeliharaan Aset
,Sales Payment Summary,Ringkasan Pembayaran Penjualan
DocType: Restaurant,Restaurant,Restoran
apps/erpnext/erpnext/accounts/party.py +323,Due / Reference Date cannot be after {0},Karena / Referensi Tanggal tidak boleh setelah {0}
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Data Impor dan Ekspor
DocType: Patient,Account Details,Rincian Account
DocType: Crop,Materials Required,Bahan yang dibutuhkan
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Tidak ada siswa Ditemukan
DocType: Medical Department,Medical Department,Departemen Kesehatan
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kriteria penilaian scorecard pemasok
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Faktur Posting Tanggal
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Menjual
DocType: Purchase Invoice,Rounded Total,Rounded Jumlah
DocType: Product Bundle,List items that form the package.,Daftar item yang membentuk paket.
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Persentase Alokasi harus sama dengan 100%
DocType: Crop Cycle,Linked Land Unit,Linked Land Unit
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Silakan pilih Posting Tanggal sebelum memilih Partai
DocType: Program Enrollment,School House,Asrama Sekolah
DocType: Serial No,Out of AMC,Dari AMC
apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Jumlah Penyusutan Memesan tidak dapat lebih besar dari total jumlah Penyusutan
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Membuat Maintenance Visit
apps/erpnext/erpnext/selling/doctype/customer/customer.py +199,Please contact to the user who have Sales Master Manager {0} role,Silahkan hubungi untuk pengguna yang memiliki penjualan Guru Manajer {0} peran
DocType: Company,Default Cash Account,Standar Rekening Kas
apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Perusahaan (bukan Pelanggan atau Pemasok) Utama.
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Hal ini didasarkan pada kehadiran mahasiswa ini
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Tidak ada siswa
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +171,Add more items or open full form,Menambahkan item atau buka formulir selengkapnya
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Catatan pengiriman {0} harus dibatalkan sebelum membatalkan Sales Order ini
apps/erpnext/erpnext/utilities/user_progress.py +256,Go to Users,Buka Pengguna
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Jumlah yang dibayarkan + Write Off Jumlah tidak bisa lebih besar dari Grand Total
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} tidak Nomor Batch berlaku untuk Stok Barang {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Note: There is not enough leave balance for Leave Type {0},Catatan: Tidak ada saldo cuti cukup bagi Leave Type {0}
apps/erpnext/erpnext/regional/india/utils.py +16,Invalid GSTIN or Enter NA for Unregistered,GSTIN tidak valid atau Enter NA untuk tidak terdaftar
DocType: Training Event,Seminar,Seminar
DocType: Program Enrollment Fee,Program Enrollment Fee,Program Pendaftaran Biaya
DocType: Item,Supplier Items,Supplier Produk
DocType: Opportunity,Opportunity Type,Peluang Type
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Perusahaan Baru
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Transaksi hanya dapat dihapus oleh pencipta Perusahaan
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.
DocType: Employee,Prefered Contact Email,Email Kontak Utama
DocType: Cheque Print Template,Cheque Width,Lebar Cek
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Memvalidasi Harga Jual untuk Item terhadap Purchase Rate atau Tingkat Penilaian
DocType: Fee Schedule,Fee Schedule,Jadwal biaya
DocType: Hub Settings,Publish Availability,Publikasikan Ketersediaan
DocType: Company,Create Chart Of Accounts Based On,Buat Bagan Of Account Berbasis Pada
apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Tidak dapat mengubahnya menjadi non-grup. Tugas Anak ada.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,Tanggal Lahir tidak dapat lebih besar dari saat ini.
,Stock Ageing,Usia Persediaan
apps/erpnext/erpnext/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Mahasiswa {0} ada terhadap pemohon mahasiswa {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Penyesuaian Pembulatan (Mata Uang Perusahaan)
apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Timesheet
DocType: Volunteer,Afternoon,Sore
apps/erpnext/erpnext/controllers/accounts_controller.py +257,{0} '{1}' is disabled,{0} '{1}' dinonaktifkan
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Ditetapkan sebagai Terbuka
DocType: Cheque Print Template,Scanned Cheque,Cek Terpindai
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Kirim email otomatis ke Kontak untuk Pengiriman transaksi.
DocType: Timesheet,Total Billable Amount,Jumlah Total Ditagih
DocType: Customer,Credit Limit and Payment Terms,Batas Kredit dan Persyaratan Pembayaran
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Butir 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Pesanan masuk
DocType: Purchase Order,Customer Contact Email,Email Kontak Pelanggan
DocType: Warranty Claim,Item and Warranty Details,Item dan Garansi Detail
DocType: Chapter,Chapter Members,Anggota Bab
DocType: Sales Team,Contribution (%),Kontribusi (%)
apps/erpnext/erpnext/controllers/accounts_controller.py +101,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Catatan: Entry Pembayaran tidak akan dibuat karena 'Cash atau Rekening Bank tidak ditentukan
apps/erpnext/erpnext/projects/doctype/project/project.py +67,Project {0} already exists,Project {0} sudah ada
DocType: Medical Department,Nursing User,Pengguna perawatan
DocType: Plant Analysis,Plant Analysis Criterias,Kriteria Analisis Tanaman
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Responsibilities,Tanggung Jawab
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Masa berlaku dari kutipan ini telah berakhir.
DocType: Expense Claim Account,Expense Claim Account,Akun Beban Klaim
DocType: Accounts Settings,Allow Stale Exchange Rates,Biarkan nilai tukar basi
DocType: Sales Person,Sales Person Name,Penjualan Person Nama
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Entrikan minimal 1 faktur dalam tabel
apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Tambah Pengguna
DocType: POS Item Group,Item Group,Item Grup
DocType: Item,Safety Stock,Persediaan Aman
DocType: Healthcare Settings,Healthcare Settings,Pengaturan Kesehatan
apps/erpnext/erpnext/projects/doctype/task/task.py +54,Progress % for a task cannot be more than 100.,Kemajuan% untuk tugas tidak bisa lebih dari 100.
DocType: Stock Reconciliation Item,Before reconciliation,Sebelum rekonsiliasi
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Untuk {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Pajak dan Biaya Ditambahkan (Perusahaan Mata Uang)
apps/erpnext/erpnext/stock/doctype/item/item.py +461,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Item Pajak Row {0} harus memiliki akun Pajak jenis atau Penghasilan atau Beban atau Dibebankan
DocType: Sales Order,Partly Billed,Sebagian Ditagih
apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Item {0} harus menjadi Asset barang Tetap
apps/erpnext/erpnext/stock/doctype/item/item.js +341,Make Variants,Buatlah Varian
DocType: Item,Default BOM,BOM Standar
DocType: Project,Total Billed Amount (via Sales Invoices),Total Jumlah Bills (via Faktur Penjualan)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Jumlah Catatan Debet
apps/erpnext/erpnext/setup/doctype/company/company.js +89,Please re-type company name to confirm,Mohon tipe nama perusahaan untuk mengkonfirmasi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Total Outstanding Amt,Jumlah Posisi Amt
DocType: Journal Entry,Printing Settings,Pengaturan pencetakan
DocType: Employee Advance,Advance Account,Uang muka
DocType: Sales Invoice,Include Payment (POS),Sertakan Pembayaran (POS)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +290,Total Debit must be equal to Total Credit. The difference is {0},Jumlah Debit harus sama dengan total kredit. Perbedaannya adalah {0}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Otomotif
DocType: Vehicle,Insurance Company,Perusahaan asuransi
DocType: Asset Category Account,Fixed Asset Account,Akun Aset Tetap
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,Variabel
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Dari Delivery Note
DocType: Chapter,Members,Anggota
DocType: Student,Student Email Address,Alamat Email Siswa
DocType: Item,Hub Warehouse,Gudang Hub
DocType: Assessment Plan,From Time,Dari Waktu
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Persediaan:
DocType: Notification Control,Custom Message,Custom Pesan
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Perbankan Investasi
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Kas atau Rekening Bank wajib untuk membuat entri pembayaran
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Alamat siswa
DocType: Purchase Invoice,Price List Exchange Rate,Daftar Harga Tukar
apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},Nomor Akun {0} sudah digunakan di akun {1}
DocType: POS Profile,POS Profile Name,Nama Profil POS
DocType: Purchase Invoice Item,Rate,Harga
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Menginternir
DocType: Delivery Stop,Address Name,Nama alamat
DocType: Stock Entry,From BOM,Dari BOM
DocType: Assessment Code,Assessment Code,Kode penilaian
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Dasar
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Transaksi persediaan sebelum {0} dibekukan
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',Silahkan klik 'Menghasilkan Jadwal'
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,Reference No is mandatory if you entered Reference Date,Referensi ada adalah wajib jika Anda memasukkan Referensi Tanggal
DocType: Bank Reconciliation Detail,Payment Document,Dokumen pembayaran
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Kesalahan dalam mengevaluasi rumus kriteria
apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,Tanggal Bergabung harus lebih besar dari Tanggal Lahir
DocType: Salary Slip,Salary Structure,Struktur Gaji
DocType: Account,Bank,Bank
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Maskapai Penerbangan
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +852,Issue Material,Isu Material
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Terjadi kesalahan saat membuat berulang
DocType: Material Request Item,For Warehouse,Untuk Gudang
DocType: Employee,Offer Date,Penawaran Tanggal
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Penawaran
apps/erpnext/erpnext/accounts/page/pos/pos.js +727,You are in offline mode. You will not be able to reload until you have network.,Anda berada dalam mode offline. Anda tidak akan dapat memuat sampai Anda memiliki jaringan.
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Tidak Grup Pelajar dibuat.
DocType: Purchase Invoice Item,Serial No,Serial ada
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Bulanan Pembayaran Jumlah tidak dapat lebih besar dari Jumlah Pinjaman
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Cukup masukkan Maintaince Detail terlebih dahulu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Baris # {0}: Tanggal Pengiriman yang Diharapkan tidak boleh sebelum Tanggal Pemesanan Pembelian
DocType: Purchase Invoice,Print Language,cetak Bahasa
DocType: Salary Slip,Total Working Hours,Jumlah Jam Kerja
DocType: Subscription,Next Schedule Date,Jadwal Jadwal Berikutnya
DocType: Stock Entry,Including items for sub assemblies,Termasuk item untuk sub rakitan
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Rekening Pembukaan Sementara
apps/erpnext/erpnext/accounts/page/pos/pos.js +1944,Enter value must be positive,Masukkan nilai harus positif
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,Semua Wilayah
DocType: Purchase Invoice,Items,Items
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,Student is already enrolled.,Mahasiswa sudah terdaftar.
DocType: Fiscal Year,Year Name,Nama Tahun
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Ada lebih dari hari kerja libur bulan ini.
DocType: Product Bundle Item,Product Bundle Item,Barang Bundel Produk
DocType: Sales Partner,Sales Partner Name,Penjualan Mitra Nama
apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Permintaan Kutipan
DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimum Faktur Jumlah
apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Hematologi
DocType: Normal Test Items,Normal Test Items,Item Uji Normal
DocType: Student Language,Student Language,Bahasa siswa
apps/erpnext/erpnext/config/selling.py +23,Customers,Pelanggan
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Order / Kuot%
apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Catat Pasien Vitals
DocType: Fee Schedule,Institution,Lembaga
DocType: Asset,Partially Depreciated,sebagian disusutkan
DocType: Issue,Opening Time,Membuka Waktu
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Dari dan Untuk tanggal yang Anda inginkan
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Efek & Bursa Komoditi
apps/erpnext/erpnext/stock/doctype/item/item.py +661,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Standar Satuan Ukur untuk Variant &#39;{0}&#39; harus sama seperti di Template &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Hitung Berbasis On
DocType: Delivery Note Item,From Warehouse,Dari Gudang
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Tidak ada karyawan untuk kriteria tersebut
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +944,No Items with Bill of Materials to Manufacture,Tidak ada Item dengan Bill of Material untuk Industri
DocType: Restaurant,Default Customer,Pelanggan default
DocType: Assessment Plan,Supervisor Name,Nama pengawas
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Jangan mengkonfirmasi jika janji dibuat untuk hari yang sama
DocType: Program Enrollment Course,Program Enrollment Course,Kursus Pendaftaran Program
DocType: Purchase Taxes and Charges,Valuation and Total,Penilaian dan Total
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Scorecard
DocType: Tax Rule,Shipping City,Pengiriman Kota
DocType: Notification Control,Customize the Notification,Sesuaikan Pemberitahuan
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Arus Kas dari Operasi
DocType: Purchase Invoice,Shipping Rule,Aturan Pengiriman
DocType: Patient Relation,Spouse,Pasangan
DocType: Lab Test Groups,Add Test,Tambahkan Test
DocType: Manufacturer,Limited to 12 characters,Terbatas untuk 12 karakter
DocType: Journal Entry,Print Heading,Cetak Pos
apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Pengiriman Trip service tours ke pelanggan.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Jumlah tidak boleh nol
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,'Hari Sejak Pesanan Terakhir' harus lebih besar dari atau sama dengan nol
DocType: Plant Analysis Criteria,Maximum Permissible Value,Nilai Maksimum yang Diijinkan
DocType: Journal Entry Account,Employee Advance,Uang muka karyawan
DocType: Payroll Entry,Payroll Frequency,Payroll Frekuensi
DocType: Lab Test Template,Sensitivity,Kepekaan
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +62,Raw Material,Bahan Baku
DocType: Leave Application,Follow via Email,Ikuti via Email
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Tanaman dan Mesin
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Jumlah pajak Setelah Diskon Jumlah
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Pengaturan Kerja Ringkasan Harian
apps/erpnext/erpnext/controllers/buying_controller.py +457,Please enter Reqd by Date,Masukkan Reqd menurut Tanggal
DocType: Payment Entry,Internal Transfer,internal transfer
DocType: Asset Maintenance,Maintenance Tasks,Tugas pemeliharaan
apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Entah sasaran qty atau jumlah target adalah wajib
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +367,Please select Posting Date first,Silakan pilih Posting Tanggal terlebih dahulu
apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Tanggal Pembukaan harus sebelum Tanggal Penutupan
DocType: Leave Control Panel,Carry Forward,Carry Teruskan
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Biaya Center dengan transaksi yang ada tidak dapat dikonversi ke buku
DocType: Department,Days for which Holidays are blocked for this department.,Hari yang Holidays diblokir untuk departemen ini.
DocType: Crop Cycle,Detected Disease,Penyakit Terdeteksi
,Produced,Diproduksi
DocType: Item,Item Code for Suppliers,Item Code untuk Supplier
DocType: Issue,Raised By (Email),Dimunculkan Oleh (Email)
DocType: Training Event,Trainer Name,Nama pelatih
DocType: Mode of Payment,General,Umum
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Komunikasi terakhir
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Tidak bisa mengurangi ketika kategori adalah untuk 'Penilaian' atau 'Penilaian dan Total'
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Nomor Seri Diperlukan untuk Barang Bernomor Seri {0}
apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Pembayaran pertandingan dengan Faktur
DocType: Journal Entry,Bank Entry,Entri Bank
DocType: Authorization Rule,Applicable To (Designation),Berlaku Untuk (Penunjukan)
,Profitability Analysis,Analisis profitabilitas
DocType: Fees,Student Email,Email Siswa
DocType: Supplier,Prevent POs,Mencegah PO
DocType: Patient,"Allergies, Medical and Surgical History","Alergi, Riwayat Medis dan Bedah"
apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Tambahkan ke Keranjang Belanja
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Kelompok Dengan
DocType: Guardian,Interests,minat
apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Mengaktifkan / menonaktifkan mata uang.
DocType: Production Planning Tool,Get Material Request,Dapatkan Material Permintaan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Beban pos
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Total (Amt)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Hiburan & Kenyamanan
,Item Variant Details,Rincian Item Variant
DocType: Quality Inspection,Item Serial No,Item Serial No
apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Buat Rekaman Karyawan
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Total Hadir
apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,Laporan akuntansi
DocType: Drug Prescription,Hour,Jam
DocType: Restaurant Order Entry,Last Sales Invoice,Faktur penjualan terakhir
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +799,Please select Qty against item {0},Silakan pilih Qty terhadap item {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,No. Seri baru tidak dapat memiliki Gudang. Gudang harus diatur oleh Entri Persediaan atau Nota Pembelian
DocType: Lead,Lead Type,Jenis Prospek
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Anda tidak berwenang untuk menyetujui cuti di Blok Tanggal
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +383,All these items have already been invoiced,Semua Stok Barang-Stok Barang tersebut telah ditagih
DocType: Company,Monthly Sales Target,Target Penjualan Bulanan
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Dapat disetujui oleh {0}
DocType: Item,Default Material Request Type,Default Bahan Jenis Permintaan
DocType: Supplier Scorecard,Evaluation Period,Periode Evaluasi
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,tidak diketahui
DocType: Shipping Rule,Shipping Rule Conditions,Aturan Pengiriman Kondisi
DocType: Purchase Invoice,Export Type,Jenis ekspor
DocType: Salary Slip Loan,Salary Slip Loan,Pinjaman Saldo Gaji
DocType: BOM Update Tool,The new BOM after replacement,The BOM baru setelah penggantian
,Point of Sale,Point of Sale
DocType: Payment Entry,Received Amount,menerima Jumlah
DocType: Patient,Widow,Janda
DocType: GST Settings,GSTIN Email Sent On,Email GSTIN Terkirim Pada
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop oleh Guardian
DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Buat kuantitas penuh, mengabaikan kuantitas sudah pada pesanan"
DocType: Crop,Planting UOM,Menanam UOM
DocType: Account,Tax,PPN
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,tidak Ditandai
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Membuka Faktur Ringkasan
DocType: Education Settings,Education Manager,Manajer Pendidikan
DocType: Production Planning Tool,Production Planning Tool,Alat Perencanaan Produksi
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Panjang minimum antara masing-masing pabrik di lapangan untuk pertumbuhan optimum
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Kumpulan Barang {0} tidak dapat diperbarui menggunakan Rekonsiliasi Persediaan, gunakan Entri Persediaan"
DocType: Quality Inspection,Report Date,Tanggal Laporan
DocType: Student,Middle Name,Nama tengah
DocType: C-Form,Invoices,Faktur
DocType: Water Analysis,Type of Sample,Jenis Sampel
DocType: Batch,Source Document Name,Nama dokumen sumber
DocType: Job Opening,Job Title,Jabatan
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} menunjukkan bahwa {1} tidak akan memberikan kutipan, namun semua item \ telah dikutip. Memperbarui status kutipan RFQ."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1004,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Sampel Maksimum - {0} telah disimpan untuk Batch {1} dan Item {2} di Batch {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Perbarui Biaya BOM secara otomatis
DocType: Lab Test,Test Name,Nama uji
apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Buat Pengguna
apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,Gram
DocType: Supplier Scorecard,Per Month,Per bulan
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,Kuantitas untuk Produksi harus lebih besar dari 0.
apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Kunjungi laporan untuk panggilan pemeliharaan.
DocType: Stock Entry,Update Rate and Availability,Perbarui Hitungan dan Ketersediaan
DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,Persentase Anda diijinkan untuk menerima atau memberikan lebih terhadap kuantitas memerintahkan. Misalnya: Jika Anda telah memesan 100 unit. dan Tunjangan Anda adalah 10% maka Anda diperbolehkan untuk menerima 110 unit.
DocType: POS Customer Group,Customer Group,Kelompok Pelanggan
apps/erpnext/erpnext/stock/doctype/batch/batch.js +120,New Batch ID (Optional),ID Batch Baru (Opsional)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Rekening pengeluaran adalah wajib untuk item {0}
DocType: BOM,Website Description,Website Description
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Perubahan Bersih Ekuitas
apps/erpnext/erpnext/hub_node/page/hub/hub.js +196,Newest,Terbaru
apps/erpnext/erpnext/assets/doctype/asset/asset.py +167,Please cancel Purchase Invoice {0} first,Batalkan Purchase Invoice {0} pertama
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","Alamat Email harus unik, sudah ada untuk {0}"
DocType: Serial No,AMC Expiry Date,Tanggal Kadaluarsa AMC
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +869,Receipt,Penerimaan
,Sales Register,Daftar Penjualan
DocType: Daily Work Summary Settings Company,Send Emails At,Kirim Email pada
DocType: Quotation,Quotation Lost Reason,Alasan Kalah Penawaran
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,Transaction reference no {0} dated {1},referensi transaksi tidak ada {0} tertanggal {1}
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Tidak ada yang mengedit.
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +483,Form View,Tampilan formulir
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Ringkasan untuk bulan ini dan kegiatan yang tertunda
apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Tambahkan pengguna ke organisasi Anda, selain dirimu sendiri."
DocType: Customer Group,Customer Group Name,Nama Kelompok Pelanggan
apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Belum ada pelanggan
apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Laporan arus kas
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Jumlah Pinjaman tidak dapat melebihi Jumlah pinjaman maksimum {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Lisensi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478,Please remove this Invoice {0} from C-Form {1},Hapus Invoice ini {0} dari C-Form {1}
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Silakan pilih Carry Teruskan jika Anda juga ingin menyertakan keseimbangan fiskal tahun sebelumnya cuti tahun fiskal ini
DocType: GL Entry,Against Voucher Type,Terhadap Tipe Voucher
DocType: Physician,Phone (R),Telepon (R)
apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Slot waktu ditambahkan
DocType: Item,Attributes,Atribut
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Aktifkan Template
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,Cukup masukkan Write Off Akun
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Order terakhir Tanggal
DocType: Patient,B Negative,B Negatif
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Status Pemeliharaan harus Dibatalkan atau Selesai untuk Dikirim
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Akun {0} bukan milik perusahaan {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +871,Serial Numbers in row {0} does not match with Delivery Note,Nomor Seri di baris {0} tidak cocok dengan Catatan Pengiriman
DocType: Student,Guardian Details,Detail wali
DocType: C-Form,C-Form,C-Form
apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Kehadiran untuk beberapa karyawan
DocType: Agriculture Task,Start Day,Mulai hari
DocType: Vehicle,Chassis No,Nomor Rangka
DocType: Payment Request,Initiated,Diprakarsai
DocType: Production Order,Planned Start Date,Direncanakan Tanggal Mulai
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +596,Please select a BOM,Silahkan pilih BOM
DocType: Serial No,Creation Document Type,Pembuatan Dokumen Type
DocType: Project Task,View Timesheet,Lihat Timesheet
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Tanggal akhir harus lebih besar dari tanggal mulai
DocType: Leave Type,Is Encash,Apakah menjual
DocType: Leave Allocation,New Leaves Allocated,cuti baru Dialokasikan
apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Data proyek-bijaksana tidak tersedia untuk Quotation
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Akhiri
DocType: Project,Expected End Date,Diharapkan Tanggal Akhir
DocType: Budget Account,Budget Amount,Jumlah anggaran
DocType: Donor,Donor Name,Nama Donor
DocType: Appraisal Template,Appraisal Template Title,Judul Template Penilaian
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Dari Tanggal {0} Karyawan {1} tidak boleh sebelum Tanggal bergabung karyawan {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Komersial
DocType: Patient,Alcohol Current Use,Penggunaan Alkohol saat ini
DocType: Student Admission Program,Student Admission Program,Program Penerimaan Mahasiswa
DocType: Payment Entry,Account Paid To,Akun Dibayar Kepada
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Induk Barang {0} tidak boleh merupakan Barang Persediaan
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Semua Produk atau Jasa.
DocType: Expense Claim,More Details,Detail Lebih
DocType: Supplier Quotation,Supplier Address,Supplier Alamat
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Anggaran untuk Akun {1} terhadap {2} {3} adalah {4}. Ini akan berlebih sebanyak {5}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695,Row {0}# Account must be of type 'Fixed Asset',Row {0} # Akun harus bertipe &#39;Fixed Asset&#39;
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Out Qty
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,dan Unchcked Disabled in
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Series adalah wajib
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Jasa Keuangan
DocType: Student Sibling,Student ID,Identitas Siswa
apps/erpnext/erpnext/hub_node/page/hub/hub.js +457,Supplier Email,Email pemasok
apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Jenis kegiatan untuk Waktu Log
DocType: Opening Invoice Creation Tool,Sales,Penjualan
DocType: Stock Entry Detail,Basic Amount,Nilai Dasar
DocType: Training Event,Exam,Ujian
DocType: Complaint,Complaint,Keluhan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +449,Warehouse required for stock Item {0},Gudang diperlukan untuk Barang Persediaan{0}
DocType: Leave Allocation,Unused leaves,cuti terpakai
DocType: Patient,Alcohol Past Use,Penggunaan Alkohol yang Telah Lalu
DocType: Fertilizer Content,Fertilizer Content,Isi pupuk
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +188,Cr,Cr
DocType: Tax Rule,Billing State,Negara penagihan
apps/erpnext/erpnext/assets/doctype/asset/asset.js +296,Transfer,Transfer
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +916,Fetch exploded BOM (including sub-assemblies),Fetch meledak BOM (termasuk sub-rakitan)
DocType: Authorization Rule,Applicable To (Employee),Berlaku Untuk (Karyawan)
apps/erpnext/erpnext/controllers/accounts_controller.py +136,Due Date is mandatory,Due Date adalah wajib
apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Kenaikan untuk Atribut {0} tidak dapat 0
DocType: Journal Entry,Pay To / Recd From,Pay To / RECD Dari
DocType: Naming Series,Setup Series,Pengaturan Series
DocType: Payment Reconciliation,To Invoice Date,Untuk Faktur Tanggal
DocType: Supplier,Contact HTML,Hubungi HTML
DocType: Disease,Treatment Period,Periode Pengobatan
apps/erpnext/erpnext/controllers/buying_controller.py +169,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Reserved Warehouse adalah wajib untuk Item {0} dalam Bahan Baku yang disediakan
,Inactive Customers,Pelanggan tidak aktif
DocType: Student Admission Program,Maximum Age,Usia Maksimum
DocType: Landed Cost Voucher,LCV,LCV
DocType: Landed Cost Voucher,Purchase Receipts,Nota Penerimaan
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Bagaimana Aturan Harga diterapkan?
DocType: Stock Entry,Delivery Note No,Pengiriman Note No
DocType: Production Planning Tool,"If checked, only Purchase material requests for final raw materials will be included in the Material Requests. Otherwise, Material Requests for parent items will be created","Jika dicentang, hanya Pembelian permintaan bahan untuk bahan baku akhir akan dimasukkan dalam Permintaan Material. Jika tidak, Permintaan Bahan untuk item orangtua akan dibuat"
DocType: Cheque Print Template,Message to show,Pesan untuk menunjukkan
apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Eceran
DocType: Student Attendance,Absent,Absen
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Bundel Produk
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Tidak dapat menemukan skor mulai dari {0}. Anda harus memiliki nilai berdiri yang mencakup 0 sampai 100
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +206,No submitted Delivery Notes found,Tidak ada catatan pengiriman yang dikirim ditemukan
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +210,Row {0}: Invalid reference {1},Row {0}: referensi tidak valid {1}
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Membeli Pajak dan Biaya Template
DocType: Timesheet,TS-,TS-
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: Salah satu dari jumlah debit atau kredit diperlukan untuk {2}
DocType: GL Entry,Remarks,Keterangan
DocType: Payment Entry,Account Paid From,Akun Dibayar Dari
DocType: Purchase Order Item Supplied,Raw Material Item Code,Bahan Baku Item Code
DocType: Task,Parent Task,Tugas orang tua
DocType: Journal Entry,Write Off Based On,Menulis Off Berbasis On
apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Membuat Prospek
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Cetak dan Alat Tulis
DocType: Stock Settings,Show Barcode Field,Tampilkan Barcode Lapangan
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +807,Send Supplier Emails,Kirim Email Pemasok
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Gaji sudah diproses untuk periode antara {0} dan {1}, Tinggalkan periode aplikasi tidak dapat antara rentang tanggal ini."
DocType: Chapter Member,Leave Reason,Tinggalkan Alasan
DocType: Guardian Interest,Guardian Interest,wali Tujuan
DocType: Volunteer,Availability,Tersedianya
apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Tetapkan nilai default untuk Faktur POS
apps/erpnext/erpnext/config/hr.py +182,Training,Latihan
DocType: Timesheet,Employee Detail,Detil karyawan
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,ID Email Guardian1
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Hari berikutnya Tanggal dan Ulangi pada Hari Bulan harus sama
DocType: Lab Prescription,Test Code,Kode uji
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Pengaturan untuk homepage website
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +38,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ tidak diizinkan untuk {0} karena kartu skor berdiri dari {1}
DocType: Delivery Stop,Select/Unselect Delivery Notes,Pilih / Hapus pilihan Catatan Pengiriman
DocType: Offer Letter,Awaiting Response,Menunggu Respon
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Di atas
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1399,Total Amount {0},Jumlah Total {0}
apps/erpnext/erpnext/controllers/item_variant.py +301,Invalid attribute {0} {1},atribut tidak valid {0} {1}
DocType: Supplier,Mention if non-standard payable account,Sebutkan jika akun hutang non-standar
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Harap pilih kelompok penilaian selain &#39;Semua Kelompok Penilaian&#39;
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Baris {0}: Pusat biaya diperlukan untuk item {1}
DocType: Training Event Employee,Optional,Pilihan
DocType: Salary Slip,Earning & Deduction,Earning & Pengurangan
DocType: Agriculture Analysis Criteria,Water Analysis,Analisis air
DocType: Chapter,Region,Wilayah
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Opsional. Pengaturan ini akan digunakan untuk menyaring dalam berbagai transaksi.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110,Negative Valuation Rate is not allowed,Tingkat Penilaian negatif tidak diperbolehkan
DocType: Holiday List,Weekly Off,Weekly Off
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Reload Linked Analysis
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Untuk misalnya 2012, 2012-13"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Laba Provisional / Rugi (Kredit)
DocType: Sales Invoice,Return Against Sales Invoice,Retur Terhadap Faktur Penjualan
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Butir 5
DocType: Serial No,Creation Time,Waktu Pembuatan
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Total Pendapatan
DocType: Patient,Other Risk Factors,Faktor Risiko Lainnya
DocType: Sales Invoice,Product Bundle Help,Bantuan Bundel Produk
,Monthly Attendance Sheet,Lembar Kehadiran Bulanan
DocType: Production Order Item,Production Order Item,Produksi Pesanan Barang
apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Tidak ada catatan ditemukan
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Biaya Asset dibatalkan
apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},"{0} {1}: ""Pusat Biaya"" adalah wajib untuk Item {2}"
DocType: Vehicle,Policy No,Kebijakan Tidak ada
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +684,Get Items from Product Bundle,Dapatkan Barang-barang dari Bundel Produk
DocType: Asset,Straight Line,Garis lurus
DocType: Project User,Project User,proyek Pengguna
apps/erpnext/erpnext/stock/doctype/batch/batch.js +64,Split,Membagi
DocType: GL Entry,Is Advance,Apakah Muka
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Kehadiran Dari Tanggal dan Kehadiran Sampai Tanggal adalah wajib
apps/erpnext/erpnext/controllers/buying_controller.py +156,Please enter 'Is Subcontracted' as Yes or No,Entrikan 'Apakah subkontrak' sebagai Ya atau Tidak
DocType: Item,Default Purchase Unit of Measure,Unit Pembelian Default
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Tanggal Komunikasi Terakhir
DocType: Sales Team,Contact No.,Hubungi Nomor
DocType: Bank Reconciliation,Payment Entries,Entries pembayaran
DocType: Land Unit,Land Unit Details,Rincian Unit Tanah
DocType: Land Unit,Latitude,Lintang
DocType: Production Order,Scrap Warehouse,Gudang memo
DocType: Production Order,Check if material transfer entry is not required,Periksa apakah entri pemindahan material tidak diperlukan
DocType: Program Enrollment Tool,Get Students From,Dapatkan Siswa Dari
apps/erpnext/erpnext/config/learn.py +273,Publish Items on Website,Publikasikan Produk di Website
apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Kelompok siswa Anda dalam batch
DocType: Authorization Rule,Authorization Rule,Regulasi Autorisasi
DocType: POS Profile,Offline POS Section,Bagian POS Offline
DocType: Sales Invoice,Terms and Conditions Details,Syarat dan Ketentuan Detail
apps/erpnext/erpnext/templates/generators/item.html +85,Specifications,Spesifikasi
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Penjualan Pajak dan Biaya Template
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Total (Kredit)
DocType: Repayment Schedule,Payment Date,Tanggal pembayaran
apps/erpnext/erpnext/stock/doctype/batch/batch.js +114,New Batch Qty,Baru Batch Qty
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Pakaian & Aksesoris
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,Tidak dapat memecahkan fungsi skor tertimbang. Pastikan rumusnya benar.
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Jumlah Order
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner yang akan muncul di bagian atas daftar produk.
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Tentukan kondisi untuk menghitung jumlah pengiriman
DocType: Program Enrollment,Institute's Bus,Bus Institut
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Peran Diizinkan Set Beku Account & Edit Frozen Entri
DocType: Supplier Scorecard Scoring Variable,Path,Jalan
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,Tidak dapat mengkonversi Pusat Biaya untuk buku karena memiliki node anak
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +66,Opening Value,Nilai pembukaan
DocType: Salary Detail,Formula,Rumus
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
DocType: Lab Test Template,Lab Test Template,Lab Test Template
apps/erpnext/erpnext/setup/doctype/company/company.py +170,Sales Account,Akun penjualan
DocType: Purchase Invoice Item,Total Weight,Berat keseluruhan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Komisi Penjualan
DocType: Offer Letter Term,Value / Description,Nilai / Keterangan
apps/erpnext/erpnext/controllers/accounts_controller.py +629,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Aset {1} tidak dapat disampaikan, itu sudah {2}"
DocType: Tax Rule,Billing Country,Negara Penagihan
DocType: Purchase Order Item,Expected Delivery Date,Diharapkan Pengiriman Tanggal
DocType: Restaurant Order Entry,Restaurant Order Entry,Entri Pemesanan Restoran
apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debit dan Kredit tidak sama untuk {0} # {1}. Perbedaan adalah {2}.
DocType: Asset Maintenance Task,Assign To Name,Berikan nama
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Beban Hiburan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +63,Make Material Request,Membuat Material Permintaan
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Terbuka Barang {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktur Penjualan {0} harus dibatalkan sebelum membatalkan Sales Order ini
DocType: Consultation,Age,Usia
DocType: Sales Invoice Timesheet,Billing Amount,Jumlah Penagihan
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Kuantitas tidak valid untuk item {0}. Jumlah harus lebih besar dari 0.
DocType: Company,Default Employee Advance Account,Akun uang muka karyawan
apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Aplikasi untuk cuti.
apps/erpnext/erpnext/accounts/doctype/account/account.py +164,Account with existing transaction can not be deleted,Akun dengan transaksi yang ada tidak dapat dihapus
DocType: Vehicle,Last Carbon Check,Terakhir Carbon Periksa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Beban Legal
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Silakan pilih kuantitas pada baris
apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Lakukan Pembukaan Faktur Penjualan dan Pembelian
DocType: Purchase Invoice,Posting Time,Posting Waktu
DocType: Timesheet,% Amount Billed,% Jumlah Ditagih
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.","""Waktu Per Pertemuan"" belum ditetapkan untuk Dr {0}. Tambahkan ke data utama Dokter."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Beban Telepon
DocType: Sales Partner,Logo,Logo
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Periksa ini jika Anda ingin untuk memaksa pengguna untuk memilih seri sebelum menyimpan. Tidak akan ada default jika Anda memeriksa ini.
apps/erpnext/erpnext/stock/get_item_details.py +129,No Item with Serial No {0},Tidak ada Stok Barang dengan Serial No {0}
DocType: Email Digest,Open Notifications,Terbuka Pemberitahuan
DocType: Payment Entry,Difference Amount (Company Currency),Perbedaan Jumlah (Perusahaan Mata Uang)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Beban Langsung
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Pendapatan Pelanggan Baru
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Biaya Perjalanan
DocType: Maintenance Visit,Breakdown,Rincian
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Tambahkan bidang kustom Langganan di doctype {0}
apps/erpnext/erpnext/controllers/accounts_controller.py +813,Account: {0} with currency: {1} can not be selected,Account: {0} dengan mata uang: {1} tidak dapat dipilih
DocType: Purchase Receipt Item,Sample Quantity,Jumlah sampel
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Perbarui biaya BOM secara otomatis melalui Penjadwalan, berdasarkan hitungan penilaian / daftar harga / hitungan pembelian bahan baku terakhir."
DocType: Bank Reconciliation Detail,Cheque Date,Cek Tanggal
apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Akun {0}: akun Induk {1} bukan milik perusahaan: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +106,Successfully deleted all transactions related to this company!,Berhasil dihapus semua transaksi yang terkait dengan perusahaan ini!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Seperti pada Tanggal
DocType: Appraisal,HR,HR
DocType: Program Enrollment,Enrollment Date,tanggal pendaftaran
DocType: Healthcare Settings,Out Patient SMS Alerts,SMS Pemberitahuan Pasien Luar
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,Percobaan
apps/erpnext/erpnext/config/hr.py +115,Salary Components,Komponen gaji
DocType: Program Enrollment Tool,New Academic Year,Baru Tahun Akademik
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +809,Return / Credit Note,Nota Retur / Kredit
DocType: Stock Settings,Auto insert Price List rate if missing,Insert auto tingkat Daftar Harga jika hilang
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23,Total Paid Amount,Jumlah Total Dibayar
DocType: Production Order Item,Transferred Qty,Ditransfer Qty
apps/erpnext/erpnext/config/learn.py +11,Navigating,Menjelajahi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Perencanaan
DocType: Material Request,Issued,Diterbitkan
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Kegiatan Siswa
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Supplier Id
DocType: Payment Request,Payment Gateway Details,Pembayaran Detail Gateway
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +267,Quantity should be greater than 0,Kuantitas harus lebih besar dari 0
DocType: Journal Entry,Cash Entry,Entri Kas
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,node anak hanya dapat dibuat di bawah &#39;Grup&#39; Jenis node
DocType: Leave Application,Half Day Date,Tanggal Setengah Hari
DocType: Academic Year,Academic Year Name,Nama Tahun Akademis
DocType: Sales Partner,Contact Desc,Contact Info
apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Jenis cuti seperti kasual, dll sakit"
DocType: Email Digest,Send regular summary reports via Email.,Mengirim laporan ringkasan berkala melalui Email.
DocType: Payment Entry,PE-,PE-
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +305,Please set default account in Expense Claim Type {0},Silakan set account default di Beban Klaim Jenis {0}
DocType: Assessment Result,Student Name,Nama siswa
DocType: Brand,Item Manager,Item Manajer
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Payroll Hutang
DocType: Buying Settings,Default Supplier Type,Standar Supplier Type
DocType: Plant Analysis,Collection Datetime,Koleksi Datetime
DocType: Production Order,Total Operating Cost,Total Biaya Operasional
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Catatan: Stok Barang {0} masuk beberapa kali
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Semua Kontak.
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Singkatan Perusahaan
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Pengguna {0} tidak ada
DocType: Payment Term,Day(s) after invoice date,Hari setelah tanggal faktur
DocType: Payment Schedule,Payment Schedule,Jadwal pembayaran
DocType: Subscription,SUB-,SUB-
DocType: Item Attribute Value,Abbreviation,Singkatan
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,Masuk pembayaran sudah ada
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Tidak Authroized sejak {0} melebihi batas
apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Template master gaji.
apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Patologi
DocType: Restaurant Order Entry,Restaurant Table,Meja restoran
DocType: Leave Type,Max Days Leave Allowed,Max Hari Cuti Diizinkan
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Set Peraturan Pajak untuk keranjang belanja
DocType: Purchase Invoice,Taxes and Charges Added,Pajak dan Biaya Ditambahkan
,Sales Funnel,Penjualan Saluran
apps/erpnext/erpnext/setup/doctype/company/company.py +48,Abbreviation is mandatory,Singkatan wajib diisi
DocType: Project,Task Progress,tugas Kemajuan
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Troli
,Qty to Transfer,Kuantitas untuk ditransfer
apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Penawaran terhadap Prospek atau Pelanggan
DocType: Stock Settings,Role Allowed to edit frozen stock,Peran diizinkan mengedit persediaan dibekukan
,Territory Target Variance Item Group-Wise,Wilayah Sasaran Variance Stok Barang Group-Wise
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Semua Kelompok Pelanggan
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,akumulasi Bulanan
apps/erpnext/erpnext/controllers/accounts_controller.py +774,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} adalah wajib. Mungkin data Kurs Mata Uang tidak dibuat untuk {1} sampai {2}.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +41,Tax Template is mandatory.,Template pajak adalah wajib.
apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Akun {0}: akun Induk {1} tidak ada
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Daftar Harga Rate (Perusahaan Mata Uang)
DocType: Products Settings,Products Settings,Pengaturan produk
,Item Price Stock,Stok Harga Barang
DocType: Lab Prescription,Test Created,Uji coba
DocType: Healthcare Settings,Custom Signature in Print,Tanda Tangan Khusus di Cetak
DocType: Account,Temporary,Sementara
DocType: Program,Courses,Kursus
DocType: Monthly Distribution Percentage,Percentage Allocation,Persentase Alokasi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Sekretaris
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Jika menonaktifkan, &#39;Dalam Kata-kata&#39; bidang tidak akan terlihat di setiap transaksi"
DocType: Serial No,Distinct unit of an Item,Unit berbeda Item
DocType: Supplier Scorecard Criteria,Criteria Name,Nama kriteria
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1289,Please set Company,Harap set Perusahaan
DocType: Pricing Rule,Buying,Pembelian
apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Penyakit &amp; Pupuk
DocType: HR Settings,Employee Records to be created by,Rekaman Karyawan yang akan dibuat oleh
DocType: Patient,AB Negative,AB Negatif
DocType: Sample Collection,SMPL-,SMPL-
DocType: POS Profile,Apply Discount On,Terapkan Diskon Pada
DocType: Member,Membership Type,jenis keanggotaan
,Reqd By Date,Reqd By Date
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Kreditor
DocType: Assessment Plan,Assessment Name,penilaian Nama
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Row # {0}: Serial ada adalah wajib
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Stok Barang Wise Detil Pajak
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Singkatan Institute
,Item-wise Price List Rate,Stok Barang-bijaksana Daftar Harga Tingkat
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +970,Supplier Quotation,Supplier Quotation
DocType: Quotation,In Words will be visible once you save the Quotation.,Dalam Kata-kata akan terlihat sekali Anda menyimpan Quotation tersebut.
apps/erpnext/erpnext/utilities/transaction_base.py +158,Quantity ({0}) cannot be a fraction in row {1},Kuantitas ({0}) tidak boleh menjadi pecahan dalam baris {1}
DocType: Consultation,C-,C-
DocType: Attendance,ATT-,ATT-
apps/erpnext/erpnext/stock/doctype/item/item.py +473,Barcode {0} already used in Item {1},Barcode {0} sudah digunakan dalam Produk {1}
apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Aturan untuk menambahkan biaya pengiriman.
DocType: Item,Opening Stock,Persediaan pembukaan
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Pelanggan diwajibkan
DocType: Lab Test,Result Date,Tanggal hasil
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} adalah wajib untuk Retur
DocType: Purchase Order,To Receive,Menerima
apps/erpnext/erpnext/utilities/user_progress.py +249,user@example.com,user@example.com
DocType: Asset,Asset Owner,Pemilik aset
DocType: Employee,Personal Email,Email Pribadi
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Total Variance
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Jika diaktifkan, sistem akan posting entri akuntansi untuk persediaan otomatis."
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Memperantarai
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Kehadiran bagi karyawan {0} sudah ditandai untuk hari ini
DocType: Production Order Operation,"in Minutes
Updated via 'Time Log'",di Menit Diperbarui melalui 'Log Waktu'
DocType: Customer,From Lead,Dari Prospek
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Order dirilis untuk produksi.
apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Pilih Tahun Anggaran ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +554,POS Profile required to make POS Entry,POS Profil diperlukan untuk membuat POS Entri
DocType: Program Enrollment Tool,Enroll Students,Daftarkan Siswa
DocType: Lab Test,Approved Date,Tanggal yang Disetujui
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standard Jual
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +148,Atleast one warehouse is mandatory,Setidaknya satu gudang adalah wajib
DocType: Serial No,Out of Warranty,Out of Garansi
DocType: BOM Update Tool,Replace,Mengganti
apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Tidak ditemukan produk.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +358,{0} against Sales Invoice {1},{0} terhadap Faktur Penjualan {1}
DocType: Antibiotic,Laboratory User,Pengguna Laboratorium
DocType: Sales Invoice,SINV-,SINV-
DocType: Request for Quotation Item,Project Name,Nama Proyek
DocType: Customer,Mention if non-standard receivable account,Menyebutkan jika non-standar piutang
DocType: Journal Entry Account,If Income or Expense,Jika Penghasilan atau Beban
DocType: Production Order,Required Items,Produk yang dibutuhkan
DocType: Stock Ledger Entry,Stock Value Difference,Perbedaan Nilai Persediaan
apps/erpnext/erpnext/config/learn.py +234,Human Resource,Sumber Daya Manusia
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Rekonsiliasi Pembayaran Pembayaran
DocType: Disease,Treatment Task,Tugas Pengobatan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Aset pajak
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +631,Production Order has been {0},Pesanan Produksi telah {0}
DocType: BOM Item,BOM No,No. BOM
DocType: Instructor,INS/,INS /
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +158,Journal Entry {0} does not have account {1} or already matched against other voucher,Jurnal Entri {0} tidak memiliki akun {1} atau sudah dicocokkan voucher lainnya
DocType: Item,Moving Average,Moving Average
DocType: BOM Update Tool,The BOM which will be replaced,BOM yang akan diganti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,Peralatan elektronik
DocType: Asset,Maintenance Required,Pemeliharaan Diperlukan
DocType: Account,Debit,Debet
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"cuti harus dialokasikan dalam kelipatan 0,5"
DocType: Production Order,Operation Cost,Biaya Operasi
apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Unggah kehadiran dari file csv.
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Posisi Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Target Set Stok Barang Group-bijaksana untuk Sales Person ini.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Bekukan Persediaan Lebih Lama Dari [Hari]
apps/erpnext/erpnext/controllers/accounts_controller.py +599,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Aset adalah wajib untuk aktiva tetap pembelian / penjualan
DocType: Asset Maintenance Team,Maintenance Team Name,Nama Tim Pemeliharaan
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Jika dua atau lebih Aturan Harga yang ditemukan berdasarkan kondisi di atas, Prioritas diterapkan. Prioritas adalah angka antara 0 sampai 20, sementara nilai default adalah nol (kosong). Jumlah yang lebih tinggi berarti akan diutamakan jika ada beberapa Aturan Harga dengan kondisi yang sama."
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Tahun Anggaran: {0} tidak ada
DocType: Currency Exchange,To Currency,Untuk Mata
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Izinkan pengguna ini untuk menyetujui aplikasi izin cuti untuk hari yang terpilih(blocked).
apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Jenis Beban Klaim.
apps/erpnext/erpnext/controllers/selling_controller.py +147,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Tingkat penjualan untuk item {0} lebih rendah dari {1} nya. Tingkat penjualan harus atleast {2}
DocType: Item,Taxes,PPN
DocType: Purchase Invoice Item,Weight Per Unit,Berat Per Unit
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Dibayar dan Tidak Terkirim
DocType: Project,Default Cost Center,Standar Biaya Pusat
DocType: Bank Guarantee,End Date,Tanggal Berakhir
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Transaksi Persediaan
DocType: Budget,Budget Accounts,Akun anggaran
DocType: Employee,Internal Work History,Sejarah Kerja internal
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Akumulasi Penyusutan Jumlah
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Supplier Scorecard Variabel
DocType: Employee Loan,Fully Disbursed,sepenuhnya Dicairkan
DocType: Maintenance Visit,Customer Feedback,Umpan balik Pelanggan
DocType: Account,Expense,Biaya
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54,Score cannot be greater than Maximum Score,Skor tidak dapat lebih besar dari skor maksimum
apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Pelanggan dan Pemasok
DocType: Item Attribute,From Range,Dari Rentang
DocType: BOM,Set rate of sub-assembly item based on BOM,Tetapkan tarif barang sub-rakitan berdasarkan BOM
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},kesalahan sintaks dalam formula atau kondisi: {0}
DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Kerja Harian Ringkasan Pengaturan Perusahaan
apps/erpnext/erpnext/stock/utils.py +123,Item {0} ignored since it is not a stock item,Barang {0} diabaikan karena bukan barang persediaan
DocType: Appraisal,APRSL,APRSL
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Submit this Production Order for further processing.,Kirim Produksi ini Order untuk diproses lebih lanjut.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Untuk tidak berlaku Rule Harga dalam transaksi tertentu, semua Aturan Harga yang berlaku harus dinonaktifkan."
DocType: Payment Term,Day(s) after the end of the invoice month,Hari setelah akhir bulan faktur
DocType: Assessment Group,Parent Assessment Group,Induk Penilaian Grup
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Pekerjaan
,Sales Order Trends,Sales Order Trends
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,The 'From Package No.' field must neither be empty nor it's value less than 1.,&#39;Dari Paket No.&#39; lapangan tidak boleh kosong atau nilainya kurang dari 1.
DocType: Employee,Held On,Diadakan Pada
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +36,Production Item,Produksi Stok Barang
,Employee Information,Informasi Karyawan
DocType: Stock Entry Detail,Additional Cost,Biaya tambahan
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +44,"Can not filter based on Voucher No, if grouped by Voucher","Tidak dapat memfilter berdasarkan No. Voucher, jika dikelompokkan berdasarkan Voucher"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +916,Make Supplier Quotation,Membuat Pemasok Quotation
DocType: Quality Inspection,Incoming,Incoming
apps/erpnext/erpnext/setup/doctype/company/company.js +70,Default tax templates for sales and purchase are created.,Template pajak default untuk penjualan dan pembelian telah dibuat.
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57,Assessment Result record {0} already exists.,Catatan Hasil Penilaian {0} sudah ada.
DocType: BOM,Materials Required (Exploded),Bahan yang dibutuhkan (Meledak)
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',Harap tentukan filter Perusahaan jika Group By &#39;Company&#39;
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Posting Tanggal tidak bisa tanggal di masa depan
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} tidak sesuai dengan {2} {3}
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,untuk menghasilkan berulang
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Santai Cuti
apps/erpnext/erpnext/config/healthcare.py +139,Lab Test UOM.,Uji Lab UOM.
DocType: Agriculture Task,End Day,Hari Akhir
DocType: Batch,Batch ID,Batch ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Catatan: {0}
,Delivery Note Trends,Tren pengiriman Note
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Ringkasan minggu ini
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Jumlah tersedia
DocType: Delivery Trip,Calculate Estimated Arrival Times,Hitung Perkiraan Waktu Kedatangan
apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Akun: {0} hanya dapat diperbarui melalui Transaksi Persediaan
DocType: Student Group Creation Tool,Get Courses,Dapatkan Program
DocType: GL Entry,Party,Pihak
DocType: Healthcare Settings,Patient Name,Nama pasien
DocType: Variant Field,Variant Field,Bidang Varian
DocType: Sales Order,Delivery Date,Tanggal Pengiriman
DocType: Opportunity,Opportunity Date,Peluang Tanggal
DocType: Purchase Receipt,Return Against Purchase Receipt,Retur Terhadap Nota Pembelian
DocType: Water Analysis,Person Responsible,Orang yang bertanggung jawab
DocType: Request for Quotation Item,Request for Quotation Item,Permintaan Quotation Barang
DocType: Purchase Order,To Bill,Bill
DocType: Material Request,% Ordered,% Tersusun
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Untuk Kelompok Siswa Berbasis Kursus, Kursus akan divalidasi untuk setiap Siswa dari Program Pendaftaran Pendaftaran Program yang terdaftar."
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Pekerjaan yg dibayar menurut hasil yg dikerjakan
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Harga Beli Rata-rata
DocType: Task,Actual Time (in Hours),Waktu Aktual (dalam Jam)
DocType: Employee,History In Company,Sejarah Dalam Perusahaan
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +311,New Message from {sender},Pesan baru dari {sender}
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Surat edaran
DocType: Drug Prescription,Description/Strength,Deskripsi / Kekuatan
DocType: Stock Ledger Entry,Stock Ledger Entry,Entri Buku Persediaan
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,item yang sama telah dimasukkan beberapa kali
DocType: Department,Leave Block List,Cuti Block List
DocType: Purchase Invoice,Tax ID,Id pajak
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,Stok Barang {0} tidak diatur untuk Nomor Seri. Kolom harus kosong
DocType: Accounts Settings,Accounts Settings,Pengaturan Akun
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,Menyetujui
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +51,"Malformatted address for {0}, please fix to continue.","Alamat berformat salah untuk {0}, tolong perbaiki untuk melanjutkan."
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix","Jumlah Akun baru, akan disertakan dalam nama akun sebagai awalan"
DocType: Maintenance Team Member,Team Member,Anggota tim
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Tidak ada hasil untuk disampaikan
DocType: Customer,Sales Partner and Commission,Penjualan Mitra dan Komisi
DocType: Employee Loan,Rate of Interest (%) / Year,Tingkat bunga (%) / Tahun
,Project Quantity,proyek Kuantitas
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Total {0} untuk semua item adalah nol, mungkin Anda harus mengubah &#39;Distribusikan Biaya Berdasarkan&#39;"
DocType: Opportunity,To Discuss,Untuk Diskusikan
apps/erpnext/erpnext/stock/stock_ledger.py +375,{0} units of {1} needed in {2} to complete this transaction.,{0} unit {1} dibutuhkan dalam {2} untuk menyelesaikan transaksi ini.
DocType: Loan Type,Rate of Interest (%) Yearly,Tingkat bunga (%) Tahunan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Akun sementara
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Hitam
DocType: BOM Explosion Item,BOM Explosion Item,Rincian Barang BOM
DocType: Account,Auditor,Akuntan
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} item diproduksi
apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Belajarlah lagi
DocType: Cheque Print Template,Distance from top edge,Jarak dari tepi atas
apps/erpnext/erpnext/stock/get_item_details.py +365,Price List {0} is disabled or does not exist,Daftar Harga {0} dinonaktifkan atau tidak ada
DocType: Purchase Invoice,Return,Retur
DocType: Production Order Operation,Production Order Operation,Order Operasi Produksi
DocType: Pricing Rule,Disable,Nonaktifkan
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Mode of payment is required to make a payment,Cara pembayaran yang diperlukan untuk melakukan pembayaran
DocType: Project Task,Pending Review,Pending Ulasan
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Edit di halaman penuh untuk lebih banyak pilihan seperti aset, serial nos, batch dll."
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Janji dan Konsultasi
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} tidak terdaftar dalam Batch {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Aset {0} tidak dapat dihapus, karena sudah {1}"
DocType: Task,Total Expense Claim (via Expense Claim),Jumlah Klaim Beban (via Beban Klaim)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Absen
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Gagal menata perusahaan
DocType: Asset Repair,Asset Repair,Perbaikan Aset
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +140,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Row {0}: Mata dari BOM # {1} harus sama dengan mata uang yang dipilih {2}
DocType: Journal Entry Account,Exchange Rate,Nilai Tukar
DocType: Patient,Additional information regarding the patient,Informasi tambahan mengenai pasien
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +572,Sales Order {0} is not submitted,Order Penjualan {0} tidak Terkirim
DocType: Homepage,Tag Line,klimaks
DocType: Fee Component,Fee Component,biaya Komponen
apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Manajemen armada
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +968,Add items from,Menambahkan item dari
apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Tanaman &amp; lahan
DocType: Cheque Print Template,Regular,Reguler
DocType: Fertilizer,Density (if liquid),Densitas (jika cair)
apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Total weightage semua Kriteria Penilaian harus 100%
DocType: Purchase Order Item,Last Purchase Rate,Tingkat Pembelian Terakhir
DocType: Account,Asset,Aset
DocType: Project Task,Task ID,Tugas ID
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Persediaan tidak bisa muncul untuk Barang {0} karena memiliki varian
DocType: Lab Test,Mobile,Mobile
,Sales Person-wise Transaction Summary,Sales Person-bijaksana Rangkuman Transaksi
DocType: Training Event,Contact Number,Nomor kontak
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Gudang {0} tidak ada
DocType: Monthly Distribution,Monthly Distribution Percentages,Persentase Distribusi bulanan
apps/erpnext/erpnext/stock/doctype/batch/batch.py +58,The selected item cannot have Batch,Item yang dipilih tidak dapat memiliki Batch
DocType: Delivery Note,% of materials delivered against this Delivery Note,% Dari materi yang Terkirim terhadap Pengiriman ini Note
DocType: Asset Maintenance Log,Has Certificate,Memiliki sertifikat
DocType: Project,Customer Details,Rincian Pelanggan
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Periksa apakah Aset memerlukan Pemeliharaan atau Kalibrasi Pencegahan
DocType: Employee,Reports to,Laporan untuk
,Unpaid Expense Claim,Tunggakan Beban Klaim
DocType: Payment Entry,Paid Amount,Dibayar Jumlah
apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Jelajahi Siklus Penjualan
DocType: Assessment Plan,Supervisor,Pengawas
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +867,Retention Stock Entry,Entri saham retensi
,Available Stock for Packing Items,Tersedia untuk Barang Paket
DocType: Item Variant,Item Variant,Item Variant
DocType: Assessment Result Tool,Assessment Result Tool,Alat Hasil penilaian
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,Sebagai pengawas
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Barang
apps/erpnext/erpnext/accounts/page/pos/pos.js +887,Submitted orders can not be deleted,perintah yang disampaikan tidak dapat dihapus
apps/erpnext/erpnext/accounts/doctype/account/account.py +114,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Saldo rekening sudah berada di Debit, Anda tidak diizinkan untuk mengatur 'Balance Harus' sebagai 'Kredit'"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Manajemen Mutu
apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Item {0} telah dinonaktifkan
DocType: Project,Total Billable Amount (via Timesheets),Total Jumlah yang Dapat Ditagih (via Timesheets)
DocType: Agriculture Task,Previous Business Day,Hari Bisnis Sebelumnya
DocType: Employee Loan,Repay Fixed Amount per Period,Membayar Jumlah Tetap per Periode
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Mohon masukkan untuk Item {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Credit Note Amt,Catatan Kredit Amt
DocType: Employee External Work History,Employee External Work History,Karyawan Eksternal Riwayat Pekerjaan
DocType: Opening Invoice Creation Tool,Purchase,Pembelian
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Jumlah Saldo
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Tujuan tidak boleh kosong
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15,Enrolling students,Mendaftar siswa
DocType: Item Group,Parent Item Group,Induk Stok Barang Grup
DocType: Appointment Type,Appointment Type,Jenis Pengangkatan
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} untuk {1}
DocType: Healthcare Settings,Valid number of days,Jumlah hari yang valid
apps/erpnext/erpnext/setup/doctype/company/company.js +39,Cost Centers,Pusat biaya
DocType: Land Unit,Linked Plant Analysis,Analisis Tanaman Tertanam
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Tingkat di mana mata uang Supplier dikonversi ke mata uang dasar perusahaan
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: konflik Timing dengan baris {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Biarkan Zero Valuation Rate
DocType: Training Event Employee,Invited,diundang
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Beberapa Struktur Gaji aktif yang ditemukan untuk karyawan {0} untuk tanggal tertentu
apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Rekening Gateway setup.
DocType: Employee,Employment Type,Jenis Pekerjaan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Aktiva Tetap
DocType: Payment Entry,Set Exchange Gain / Loss,Set Efek Gain / Loss
,GST Purchase Register,Daftar Pembelian GST
,Cash Flow,Arus kas
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Periode aplikasi tidak bisa di dua catatan alokasi
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Bagian invoice gabungan harus sama dengan 100%
DocType: Item Group,Default Expense Account,Beban standar Akun
DocType: GST Account,CGST Account,Akun CGST
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,ID Email Siswa
DocType: Employee,Notice (days),Notice (hari)
DocType: Tax Rule,Sales Tax Template,Template Pajak Penjualan
apps/erpnext/erpnext/accounts/page/pos/pos.js +2468,Select items to save the invoice,Pilih item untuk menyimpan faktur
DocType: Employee,Encashment Date,Pencairan Tanggal
DocType: Training Event,Internet,Internet
DocType: Special Test Template,Special Test Template,Template Uji Khusus
DocType: Account,Stock Adjustment,Penyesuaian Persediaan
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Standar Kegiatan Biaya ada untuk Jenis Kegiatan - {0}
DocType: Production Order,Planned Operating Cost,Direncanakan Biaya Operasi
DocType: Academic Term,Term Start Date,Jangka Mulai Tanggal
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +242,Please find attached {0} #{1},Silakan menemukan terlampir {0} # {1}
apps/erpnext/erpnext/controllers/accounts_controller.py +721,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Jumlah Pembayaran Total dalam Jadwal Pembayaran harus sama dengan Grand / Rounded Total
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Saldo Laporan Bank sesuai Buku Besar
DocType: Job Applicant,Applicant Name,Nama Pemohon
DocType: Authorization Rule,Customer / Item Name,Nama Pelanggan / Barang
DocType: Buying Settings,"If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt","Jika diaktifkan, rincian pembelian terakhir barang tidak akan diambil dari pesanan pembelian sebelumnya atau tanda terima pembelian"
DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".

For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.

Note: BOM = Bill of Materials","Menggabungkan sekumpulan **Barang-barang** menjadi **Barang** lain. Hal ini berguna bila anda menyusun **Barang-barang** tertentu menjadi sebuah paket dan anda mengelola persediaan **Barang-barang** paket dan bukan sekumpulan **Barang**. **Barang** paket akan menampilkan ""Tidak"" pada ""Barang Stok"" dan ""Ya"" pada ""Barang Jualan"". Sebagai contoh: jika anda menjual Laptop dan Ransel secara terpisah namun memiliki harga khusus bila pelanggan membeli keduanya, maka Laptop + Backpack akan menjadi barang Bundel Produk baru. Catatan: BOM = Bill of Materials"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Serial ada adalah wajib untuk Item {0}
DocType: Item Variant Attribute,Attribute,Atribut
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Silakan tentukan dari / ke berkisar
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Membuka {0} Faktur dibuat
DocType: Serial No,Under AMC,Di bawah AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Tingkat penilaian Item dihitung ulang mengingat mendarat biaya jumlah voucher
apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Pengaturan default untuk menjual transaksi.
DocType: Guardian,Guardian Of ,wali Of
DocType: Grading Scale Interval,Threshold,Ambang
DocType: BOM Update Tool,Current BOM,BOM saat ini
apps/erpnext/erpnext/public/js/utils.js +49,Add Serial No,Tambahkan Nomor Serial
DocType: Production Order Item,Available Qty at Source Warehouse,Tersedia Qty di Gudang Sumber
apps/erpnext/erpnext/config/support.py +22,Warranty,Jaminan
DocType: Purchase Invoice,Debit Note Issued,Debit Note Ditempatkan
DocType: Production Order,Warehouses,Gudang
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} aset tidak dapat ditransfer
apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Item ini adalah Variant dari {0} (Template).
DocType: Workstation,per hour,per jam
apps/erpnext/erpnext/config/buying.py +7,Purchasing,pembelian
DocType: Announcement,Announcement,Pengumuman
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Untuk Kelompok Siswa berbasis Batch, Student Batch akan divalidasi untuk setiap Siswa dari Program Enrollment."
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Gudang tidak dapat dihapus karena ada entri buku persediaan untuk gudang ini.
apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Distribusi
DocType: Expense Claim Advance,Expense Claim Advance,Klaim Biaya Klaim
DocType: Lab Test,Report Preference,Preferensi Laporan
apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Informasi sukarela
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Manager Project
,Quoted Item Comparison,Perbandingan Produk/Barang yang ditawarkan
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Tumpang tindih dalam penilaian antara {0} dan {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Pengiriman
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,Max discount allowed for item: {0} is {1}%,Diskon Max diperbolehkan untuk item: {0} {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Nilai Aktiva Bersih seperti pada
DocType: Crop,Produce,Menghasilkan
DocType: Account,Receivable,Piutang
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Tidak diperbolehkan untuk mengubah Supplier sebagai Purchase Order sudah ada
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Peran yang diperbolehkan untuk mengirimkan transaksi yang melebihi batas kredit yang ditetapkan.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +978,Select Items to Manufacture,Pilih Produk untuk Industri
DocType: Delivery Stop,Delivery Stop,Berhenti pengiriman
apps/erpnext/erpnext/accounts/page/pos/pos.js +955,"Master data syncing, it might take some time","Data master sinkronisasi, itu mungkin memakan waktu"
DocType: Item,Material Issue,Keluar Barang
DocType: Employee Education,Qualification,Kualifikasi
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +40,View Salary Slips,Lihat Gaji Slip
DocType: Item Price,Item Price,Item Price
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Sabun & Deterjen
DocType: BOM,Show Items,Tampilkan Produk
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Dari waktu tidak dapat lebih besar dari Untuk Waktu.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +74,Do you want to notify all the customers by email?,Apakah Anda ingin memberi tahu semua pelanggan melalui email?
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Motion Picture & Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Ordered
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Lanjut
DocType: Salary Detail,Component,Komponen
DocType: Assessment Criteria,Assessment Criteria Group,Kriteria penilaian Grup
DocType: Healthcare Settings,Patient Name By,Nama Pasien Oleh
apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Membuka Penyusutan Akumulasi harus kurang dari sama dengan {0}
DocType: Warehouse,Warehouse Name,Nama Gudang
DocType: Naming Series,Select Transaction,Pilih Transaksi
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Entrikan Menyetujui Peran atau Menyetujui Pengguna
DocType: Journal Entry,Write Off Entry,Menulis Off Entri
DocType: BOM,Rate Of Materials Based On,Laju Bahan Berbasis On
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Dukungan Analtyics
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Jangan tandai semua
DocType: POS Profile,Terms and Conditions,Syarat dan Ketentuan
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},Untuk tanggal harus dalam Tahun Anggaran. Dengan asumsi To Date = {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Di sini Anda dapat mempertahankan tinggi, berat, alergi, masalah medis dll"
DocType: Leave Block List,Applies to Company,Berlaku untuk Perusahaan
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +222,Cannot cancel because submitted Stock Entry {0} exists,Tidak bisa membatalkan karena ada Entri Persediaan {0} terkirim
DocType: Employee Loan,Disbursement Date,pencairan Tanggal
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,'Penerima' belum ditentukan
DocType: BOM Update Tool,Update latest price in all BOMs,Perbarui harga terbaru di semua BOM
apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +39,Medical Record,Rekam medis
DocType: Vehicle,Vehicle,Kendaraan
DocType: Purchase Invoice,In Words,Dalam Kata
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} harus diserahkan
DocType: POS Profile,Item Groups,Grup Item
apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Hari ini adalah {0} 's birthday!
DocType: Production Planning Tool,Material Request For Warehouse,Permintaan Material Untuk Gudang
DocType: Sales Order Item,For Production,Untuk Produksi
DocType: Payment Request,payment_url,payment_url
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +163,Please add a Temporary Opening account in Chart of Accounts,Harap tambahkan akun Pembukaan Sementara di Bagan Akun
DocType: Customer,Customer Primary Contact,Kontak utama pelanggan
DocType: Project Task,View Task,Lihat Task
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Peluang/Prospek %
DocType: Material Request,MREQ-,MREQ-
DocType: Payment Schedule,Invoice Portion,Bagian faktur
,Asset Depreciations and Balances,Penyusutan aset dan Saldo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} transferred from {2} to {3},Jumlah {0} {1} ditransfer dari {2} untuk {3}
DocType: Sales Invoice,Get Advances Received,Dapatkan Uang Muka Diterima
DocType: Email Digest,Add/Remove Recipients,Tambah / Hapus Penerima
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +491,Transaction not allowed against stopped Production Order {0},Transaksi tidak diperbolehkan berhenti melawan Orde Produksi {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Untuk mengatur Tahun Anggaran ini sebagai Default, klik 'Set as Default'"
apps/erpnext/erpnext/projects/doctype/project/project.py +216,Join,Bergabung
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Kekurangan Jumlah
apps/erpnext/erpnext/stock/doctype/item/item.py +645,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Tidak dapat mengubah sifat Variant setelah stock transction. Anda harus membuat Item baru untuk melakukan ini.
apps/erpnext/erpnext/stock/doctype/item/item.py +685,Item variant {0} exists with same attributes,Item varian {0} ada dengan atribut yang sama
DocType: Employee Loan,Repay from Salary,Membayar dari Gaji
DocType: Leave Application,LAP/,PUTARAN/
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},Meminta pembayaran terhadap {0} {1} untuk jumlah {2}
DocType: Salary Slip,Salary Slip,Slip Gaji
DocType: Lead,Lost Quotation,Quotation hilang
apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Batch Siswa
DocType: Pricing Rule,Margin Rate or Amount,Tingkat margin atau Jumlah
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,'Tanggal Akhir' harus diisi
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Menghasilkan kemasan slip paket yang akan dikirimkan. Digunakan untuk memberitahu nomor paket, isi paket dan berat."
DocType: Sales Invoice Item,Sales Order Item,Stok barang Order Penjualan
DocType: Salary Slip,Payment Days,Hari Jeda Pembayaran
DocType: Stock Settings,Convert Item Description to Clean HTML,Mengkonversi Deskripsi Item untuk Bersihkan HTML
DocType: Patient,Dormant,Terbengkalai
DocType: Salary Slip,Total Interest Amount,Jumlah Bunga Total
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Gudang dengan node anak tidak dapat dikonversi ke buku besar
DocType: BOM,Manage cost of operations,Kelola biaya operasional
DocType: Accounts Settings,Stale Days,Hari basi
DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Ketika salah satu transaksi yang dicentang ""Dikirim"", pop-up email secara otomatis terbuka untuk mengirim email ke ""Kontak"" terkait dalam transaksi itu, dengan transaksi sebagai lampiran. Pengguna bisa mengirim email tersebut atau tidak mengirim."
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Pengaturan global
DocType: Crop,Row Spacing UOM,Row Spacing UOM
DocType: Assessment Result Detail,Assessment Result Detail,Penilaian Detil Hasil
DocType: Employee Education,Employee Education,Pendidikan Karyawan
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Kelompok barang duplikat yang ditemukan dalam tabel grup item
DocType: Land Unit,Parent Land Unit,Unit Induk Tanah
apps/erpnext/erpnext/public/js/controllers/transaction.js +1101,It is needed to fetch Item Details.,Hal ini diperlukan untuk mengambil Item detail.
DocType: Fertilizer,Fertilizer Name,Nama pupuk
DocType: Salary Slip,Net Pay,Nilai Bersih Terbayar
DocType: Account,Account,Akun
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serial ada {0} telah diterima
,Requested Items To Be Transferred,Permintaan Produk Akan Ditransfer
DocType: Expense Claim,Vehicle Log,kendaraan Log
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Adanya demam (suhu&gt; 38,5 ° C / 101,3 ° F atau suhu bertahan&gt; 38 ° C / 100,4 ° F)"
DocType: Customer,Sales Team Details,Rincian Tim Penjualan
apps/erpnext/erpnext/accounts/page/pos/pos.js +1342,Delete permanently?,Hapus secara permanen?
DocType: Expense Claim,Total Claimed Amount,Jumlah Total Diklaim
apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potensi peluang untuk menjadi penjualan.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Valid {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Cuti Sakit
DocType: Email Digest,Email Digest,Ringkasan Surel
DocType: Delivery Note,Billing Address Name,Nama Alamat Penagihan
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Departmen Store
,Item Delivery Date,Tanggal Pengiriman Barang
DocType: Warehouse,PIN,PIN
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +125,Error '{0}' occured. Arguments {1}.,Kesalahan &#39;{0}&#39; terjadi. Argumen {1}.
DocType: Bin,Reserved Qty for sub contract,Reserved Qty untuk sub kontrak
DocType: Sales Invoice,Base Change Amount (Company Currency),Dasar Nilai Tukar (Mata Uang Perusahaan)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Tidak ada entri akuntansi untuk gudang berikut
apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Simpan dokumen terlebih dahulu.
apps/erpnext/erpnext/shopping_cart/cart.py +71,Only {0} in stock for item {1},Hanya {0} yang tersedia untuk item {1}
DocType: Account,Chargeable,Dapat Dibebankan
DocType: Company,Change Abbreviation,Ubah Singkatan
DocType: Expense Claim Detail,Expense Date,Beban Tanggal
DocType: Item,Max Discount (%),Max Diskon (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Hari Kredit tidak bisa menjadi angka negatif
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Jumlah Order terakhir
apps/erpnext/erpnext/stock/doctype/item/item.py +264," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Sampel disimpan berdasarkan batch, tandai Nomor Batch untuk menyimpan sampel barang"
DocType: Task,Is Milestone,Adalah tonggak
DocType: Delivery Stop,Email Sent To,Surel Dikirim Ke
DocType: Budget,Warn,Peringatan: Cuti aplikasi berisi tanggal blok berikut
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Anda yakin ingin membatalkan pendaftaran?
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Setiap komentar lain, upaya penting yang harus pergi dalam catatan."
DocType: Asset Maintenance,Manufacturing User,Manufaktur Pengguna
DocType: Purchase Invoice,Raw Materials Supplied,Bahan Baku Disupply
DocType: C-Form,Series,Seri
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +273,Currency of the price list {0} must be {1} or {2},Mata uang dari daftar harga {0} harus {1} atau {2}
DocType: Appraisal,Appraisal Template,Template Penilaian
DocType: Soil Texture,Ternary Plot,Ternary Plot
DocType: Item Group,Item Classification,Klasifikasi Stok Barang
DocType: Driver,License Number,Nomor lisensi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Business Development Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Pemeliharaan Visit Tujuan
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Pendaftaran Faktur Pasien
DocType: Crop,Period,periode
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,General Ledger
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Karyawan {0} pada Cuti pada {1}
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Lihat Prospek
DocType: Program Enrollment Tool,New Program,Program baru
DocType: Item Attribute Value,Attribute Value,Nilai Atribut
,Itemwise Recommended Reorder Level,Itemwise Rekomendasi Reorder Tingkat
DocType: Salary Detail,Salary Detail,Detil gaji
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,Silahkan pilih {0} terlebih dahulu
DocType: Appointment Type,Physician,Dokter
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +850,Batch {0} of Item {1} has expired.,Kumpulan {0} Barang {1} telah berakhir.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Konsultasi
DocType: Sales Invoice,Commission,Komisi
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Waktu Lembar untuk manufaktur.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Subtotal
DocType: Physician,Charges,Biaya
DocType: Salary Detail,Default Amount,Jumlah Standar
DocType: Lab Test Template,Descriptive,Deskriptif
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95,Warehouse not found in the system,Gudang tidak ditemukan dalam sistem
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Ringkasan ini Bulan ini
DocType: Quality Inspection Reading,Quality Inspection Reading,Nilai Inspeksi Mutu
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,'Bekukan Persediaan Lebih Lama Dari' harus lebih kecil dari %d hari.
DocType: Tax Rule,Purchase Tax Template,Pembelian Template Pajak
apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,Tetapkan sasaran penjualan yang ingin Anda capai untuk perusahaan Anda.
,Project wise Stock Tracking,Pelacakan Persediaan menurut Proyek
DocType: GST HSN Code,Regional,Daerah
apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratorium
DocType: Stock Entry Detail,Actual Qty (at source/target),Jumlah Aktual (di sumber/target)
DocType: Item Customer Detail,Ref Code,Ref Kode
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Grup Pelanggan Diperlukan di Profil POS
apps/erpnext/erpnext/config/hr.py +12,Employee records.,Catatan karyawan.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +95,Please set Next Depreciation Date,Silahkan mengatur Berikutnya Penyusutan Tanggal
DocType: HR Settings,Payroll Settings,Pengaturan Payroll
apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Cocokkan Faktur non-linked dan Pembayaran.
DocType: POS Settings,POS Settings,Pengaturan POS
apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Order
DocType: Email Digest,New Purchase Orders,Pesanan Pembelian Baru
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Root tidak dapat memiliki pusat biaya orang tua
apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Pilih Merek ...
apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Non Profit (beta)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Acara / Hasil Pelatihan
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Akumulasi Penyusutan seperti pada
DocType: Sales Invoice,C-Form Applicable,C-Form Berlaku
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},Operasi Waktu harus lebih besar dari 0 untuk operasi {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Gudang adalah wajib
DocType: Supplier,Address and Contacts,Alamat dan Kontak
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Gagal membuat situs web
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,Detil UOM Konversi
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +922,Retention Stock Entry already created or Sample Quantity not provided,Entry Stok Retensi sudah dibuat atau Jumlah Sampel tidak disediakan
DocType: Program,Program Abbreviation,Singkatan Program
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,Production Order cannot be raised against a Item Template,Order produksi tidak dapat diajukan terhadap Template Stok Barang
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Ongkos dalam Nota Pembelian diperbarui terhadap setiap barang
DocType: Warranty Claim,Resolved By,Terselesaikan Dengan
DocType: Bank Guarantee,Start Date,Tanggal Mulai
apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Alokasi cuti untuk periode tertentu
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Cek dan Deposit tidak benar dibersihkan
apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Akun {0}: Anda tidak dapat menetapkanya sebagai Akun Induk
DocType: Purchase Invoice Item,Price List Rate,Daftar Harga Tingkat
apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Buat kutipan pelanggan
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Tampilkan ""Tersedia"" atau ""Tidak Tersedia"" berdasarkan persediaan di gudang ini."
apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Bill of Material (BOM)
DocType: Item,Average time taken by the supplier to deliver,Rata-rata waktu yang dibutuhkan oleh Supplier untuk memberikan
DocType: Sample Collection,Collected By,Dikumpulkan Oleh
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35,Assessment Result,penilaian Hasil
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Jam
DocType: Project,Expected Start Date,Diharapkan Tanggal Mulai
apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Laporan Detail Variant
DocType: Setup Progress Action,Setup Progress Action,Setup Progress Action
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Buying Price List,Daftar harga beli
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Hapus item jika biaya ini tidak berlaku untuk item
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Harap pilih Status Pemeliharaan sebagai Selesai atau hapus Tanggal Penyelesaian
DocType: Supplier,Default Payment Terms Template,Template Persyaratan Pembayaran Default
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Transaksi mata uang harus sama dengan Payment Gateway mata uang
DocType: Payment Entry,Receive,Menerima
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Penawaran:
DocType: Maintenance Visit,Fully Completed,Sepenuhnya Selesai
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Lengkap
DocType: Employee,Educational Qualification,Kualifikasi Pendidikan
DocType: Workstation,Operating Costs,Biaya Operasional
DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Tindakan jika Akumulasi Anggaran Bulanan Melebihi
DocType: Subscription,Submit on creation,Kirim pada penciptaan
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +470,Currency for {0} must be {1},Mata uang untuk {0} harus {1}
DocType: Asset,Disposal Date,pembuangan Tanggal
DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","Email akan dikirim ke semua Karyawan Aktif perusahaan pada jam tertentu, jika mereka tidak memiliki liburan. Ringkasan tanggapan akan dikirim pada tengah malam."
DocType: Employee Leave Approver,Employee Leave Approver,Approver Cuti Karyawan
apps/erpnext/erpnext/stock/doctype/item/item.py +485,Row {0}: An Reorder entry already exists for this warehouse {1},Baris {0}: Entri perekam sudah ada untuk gudang ini {1}
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Tidak dapat mendeklarasikan sebagai hilang, karena Quotation telah dibuat."
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,pelatihan Masukan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +488,Production Order {0} must be submitted,Order produksi {0} harus diserahkan
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kriteria Scorecard Pemasok
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Silakan pilih Tanggal Mulai dan Tanggal Akhir untuk Item {0}
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Tentu saja adalah wajib berturut-turut {0}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Sampai saat ini tidak dapat sebelumnya dari tanggal
DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DocType
apps/erpnext/erpnext/stock/doctype/item/item.js +268,Add / Edit Prices,Tambah / Edit Harga
DocType: Batch,Parent Batch,Induk induk
DocType: Cheque Print Template,Cheque Print Template,Template Print Cek
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Bagan Pusat Biaya
DocType: Lab Test Template,Sample Collection,Koleksi Sampel
,Requested Items To Be Ordered,Produk Diminta Akan Memerintahkan
apps/erpnext/erpnext/hub_node/page/hub/hub.js +655,My Orders,Order saya
DocType: Price List,Price List Name,Daftar Harga Nama
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Ringkasan Pekerjaan sehari-hari untuk {0}
DocType: BOM,Manufacturing,Manufaktur
,Ordered Items To Be Delivered,Ordered Items Akan Terkirim
DocType: Account,Income,Penghasilan
DocType: Industry Type,Industry Type,Jenis Produksi
apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Ada yang salah!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +124,Warning: Leave application contains following block dates,Peringatan: Cuti aplikasi berisi tanggal blok berikut
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,Faktur Penjualan {0} telah terkirim
DocType: Supplier Scorecard Scoring Criteria,Score,Skor
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Tahun fiskal {0} tidak ada
DocType: Asset Maintenance Log,Completion Date,Tanggal Penyelesaian
DocType: Purchase Invoice Item,Amount (Company Currency),Nilai Jumlah (mata uang perusahaan)
DocType: Agriculture Analysis Criteria,Agriculture User,Pengguna pertanian
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Berlaku sampai tanggal tidak dapat dilakukan sebelum tanggal transaksi
apps/erpnext/erpnext/stock/stock_ledger.py +379,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} unit {1} dibutuhkan dalam {2} pada {3} {4} untuk {5} untuk menyelesaikan transaksi ini.
DocType: Fee Schedule,Student Category,Mahasiswa Kategori
DocType: Announcement,Student,Mahasiswa
apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Unit Organisasi (kawasan) menguasai.
DocType: Shipping Rule,Shipping Rule Type,Jenis aturan pengiriman
apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Pergi ke kamar
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Entrikan pesan sebelum mengirimnya
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLICATE UNTUK PEMASOK
DocType: Email Digest,Pending Quotations,tertunda Kutipan
apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Profil Point of Sale
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Pinjaman tanpa Jaminan
DocType: Cost Center,Cost Center Name,Nama Pusat Biaya
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Max jam bekerja melawan Timesheet
DocType: Maintenance Schedule Detail,Scheduled Date,Dijadwalkan Tanggal
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +88,Total Paid Amt,Total nilai Bayar
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Pesan lebih dari 160 karakter akan dipecah menjadi beberapa pesan
DocType: Purchase Receipt Item,Received and Accepted,Diterima dan Diterima
DocType: Hub Settings,Company and Seller Profile,Profil Perusahaan dan Penjual
,GST Itemised Sales Register,Daftar Penjualan Item GST
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Masa Kadaluwarsa Nomor Seri Kontrak Jasa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +297,You cannot credit and debit same account at the same time,Anda tidak dapat mengkredit dan mendebit rekening yang sama secara bersamaan
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Denyut nadi orang dewasa adalah antara 50 dan 80 denyut per menit.
DocType: Naming Series,Help HTML,Bantuan HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Alat Grup Pelajar Creation
DocType: Item,Variant Based On,Varian Berbasis Pada
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Jumlah weightage ditugaskan harus 100%. Ini adalah {0}
apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,Pemasok Anda
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Perbaiki
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,Tidak dapat ditetapkan sebagai Hilang sebagai Sales Order dibuat.
DocType: Request for Quotation Item,Supplier Part No,Pemasok Bagian Tidak
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',tidak bisa memotong ketika kategori adalah untuk &#39;Penilaian&#39; atau &#39;Vaulation dan Total&#39;
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Received From,Diterima dari
DocType: Lead,Converted,Dikonversi
DocType: Item,Has Serial No,Bernomor Seri
DocType: Employee,Date of Issue,Tanggal Issue
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +24,{0}: From {0} for {1},{0}: Dari {0} untuk {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Sesuai dengan Setelan Pembelian jika Diperlukan Pembelian Diperlukan == &#39;YA&#39;, maka untuk membuat Purchase Invoice, pengguna harus membuat Purchase Receipt terlebih dahulu untuk item {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Row # {0}: Set Supplier untuk item {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Row {0}: nilai Jam harus lebih besar dari nol.
apps/erpnext/erpnext/stock/doctype/item/item.py +185,Website Image {0} attached to Item {1} cannot be found,Website Image {0} melekat Butir {1} tidak dapat ditemukan
DocType: Issue,Content Type,Tipe Konten
DocType: Asset,Assets,Aktiva
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Komputer
DocType: Item,List this Item in multiple groups on the website.,Daftar Stok Barang ini dalam beberapa kelompok di website.
DocType: Payment Term,Due Date Based On,Tanggal Jatuh Tempo Berdasarkan
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Harap atur grup pelanggan dan wilayah default di Setelan Penjualan
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +203,{0} {1} does not exist,{0} {1} tidak ada
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +321,Please check Multi Currency option to allow accounts with other currency,Silakan periksa opsi Mata multi untuk memungkinkan account dengan mata uang lainnya
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +85,Item: {0} does not exist in the system,Item: {0} tidak ada dalam sistem
apps/erpnext/erpnext/accounts/doctype/account/account.py +106,You are not authorized to set Frozen value,Anda tidak diizinkan menetapkan nilai yg sedang dibekukan
DocType: Payment Reconciliation,Get Unreconciled Entries,Dapatkan Entries Unreconciled
DocType: Payment Reconciliation,From Invoice Date,Dari Faktur Tanggal
DocType: Healthcare Settings,Laboratory Settings,Pengaturan Laboratorium
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Tinggalkan Pencairan
apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Apa pekerjaannya?
DocType: Crop,Byproducts,Produk sampingan
apps/erpnext/erpnext/stock/doctype/batch/batch.js +76,To Warehouse,Untuk Gudang
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Semua Penerimaan Mahasiswa
,Average Commission Rate,Rata-rata Komisi Tingkat
apps/erpnext/erpnext/stock/doctype/item/item.py +434,'Has Serial No' can not be 'Yes' for non-stock item,'Bernomor Seri' tidak dapat ‘Ya’ untuk barang non-persediaan
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Pilih Status
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Kehadiran tidak dapat ditandai untuk tanggal masa depan
DocType: Pricing Rule,Pricing Rule Help,Aturan Harga Bantuan
DocType: School House,House Name,Nama rumah
DocType: Fee Schedule,Total Amount per Student,Jumlah Total per Siswa
DocType: Purchase Taxes and Charges,Account Head,Akun Kepala
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Listrik
apps/erpnext/erpnext/utilities/activation.py +100,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Tambahkan sisa organisasi Anda sebagai pengguna Anda. Anda juga dapat menambahkan mengundang Pelanggan portal Anda dengan menambahkan mereka dari Kontak
DocType: Stock Entry,Total Value Difference (Out - In),Total Nilai Selisih (Out - Dalam)
DocType: Grant Application,Requested Amount,Jumlah yang diminta
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +346,Row {0}: Exchange Rate is mandatory,Row {0}: Kurs adalah wajib
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},User ID tidak ditetapkan untuk Karyawan {0}
DocType: Vehicle,Vehicle Value,Nilai kendaraan
DocType: Crop Cycle,Detected Diseases,Penyakit Terdeteksi
DocType: Stock Entry,Default Source Warehouse,Standar Gudang Sumber
DocType: Item,Customer Code,Kode Pelanggan
apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Birthday Reminder untuk {0}
DocType: Asset Maintenance Task,Last Completion Date,Tanggal penyelesaian terakhir
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Jumlah Hari Semenjak Order Terakhir
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +352,Debit To account must be a Balance Sheet account,Debit Untuk akun harus rekening Neraca
DocType: Buying Settings,Naming Series,Series Penamaan
DocType: Leave Block List,Leave Block List Name,Cuti Nama Block List
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Tanggal asuransi mulai harus kurang dari tanggal asuransi End
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Asset Persediaan
DocType: Timesheet,Production Detail,Detil produksi
DocType: Restaurant,Active Menu,Menu Aktif
DocType: Target Detail,Target Qty,Qty Target
DocType: Shopping Cart Settings,Checkout Settings,Pengaturan Checkout
DocType: Student Attendance,Present,ada
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Pengiriman Note {0} tidak boleh Terkirim
DocType: Notification Control,Sales Invoice Message,Pesan Faktur Penjualan
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Penutupan Rekening {0} harus dari jenis Kewajiban / Ekuitas
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325,Salary Slip of employee {0} already created for time sheet {1},Slip Gaji karyawan {0} sudah dibuat untuk daftar absen {1}
DocType: Vehicle Log,Odometer,Odometer
DocType: Sales Order Item,Ordered Qty,Qty Terorder
apps/erpnext/erpnext/stock/doctype/item/item.py +713,Item {0} is disabled,Item {0} dinonaktifkan
DocType: Stock Settings,Stock Frozen Upto,Stock Frozen Upto
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +929,BOM does not contain any stock item,BOM tidak berisi barang persediaan apapun
DocType: Chapter,Chapter Head,Kepala Bab
DocType: Payment Term,Month(s) after the end of the invoice month,Bulan setelah akhir bulan faktur
apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Kegiatan proyek / tugas.
DocType: Vehicle Log,Refuelling Details,Detail Pengisian
apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Buat Slip Gaji
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"Buying must be checked, if Applicable For is selected as {0}","Membeli harus dicentang, jika ""Berlaku Untuk"" dipilih sebagai {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Diskon harus kurang dari 100
DocType: Shipping Rule,Restrict to Countries,Batasi ke Negara
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +171,Select Delivery Notes,Pilih Catatan Pengiriman
DocType: Purchase Invoice,Write Off Amount (Company Currency),Jumlah Nilai Write Off (mata uang perusahaan)
DocType: Sales Invoice Timesheet,Billing Hours,Jam penagihan
DocType: Project,Total Sales Amount (via Sales Order),Total Jumlah Penjualan (via Sales Order)
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +529,Default BOM for {0} not found,BOM default untuk {0} tidak ditemukan
apps/erpnext/erpnext/stock/doctype/item/item.py +489,Row #{0}: Please set reorder quantity,Row # {0}: Silakan mengatur kuantitas menyusun ulang
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Ketuk item untuk menambahkannya di sini
DocType: Fees,Program Enrollment,Program Pendaftaran
DocType: Landed Cost Voucher,Landed Cost Voucher,Voucher Landing Cost
apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Silakan set {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} adalah siswa tidak aktif
DocType: Employee,Health Details,Detail Kesehatan
DocType: Offer Letter,Offer Letter Terms,Term Surat Penawaran
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Untuk membuat dokumen referensi Request Request diperlukan
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Grant Application,Assessment  Manager,Manajer Penilaian
DocType: Payment Entry,Allocate Payment Amount,Alokasikan Jumlah Pembayaran
DocType: Employee External Work History,Salary,Gaji
DocType: Serial No,Delivery Document Type,Tipe Nota Pengiriman
DocType: Sales Order,Partly Delivered,Terkirim Sebagian
DocType: Item Variant Settings,Do not update variants on save,Jangan perbarui varian pada saat menyimpan data
DocType: Email Digest,Receivables,Piutang
DocType: Lead Source,Lead Source,Sumber Prospek
DocType: Customer,Additional information regarding the customer.,Informasi tambahan mengenai customer.
DocType: Quality Inspection Reading,Reading 5,Membaca 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +225,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} dikaitkan dengan {2}, namun Akun Para Pihak adalah {3}"
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Lihat Tes Lab
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Tanggal Pemeliharaan
DocType: Purchase Invoice Item,Rejected Serial No,Serial No Barang Ditolak
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,Tahun tanggal mulai atau tanggal akhir ini tumpang tindih dengan {0}. Untuk menghindari silakan atur perusahaan
apps/erpnext/erpnext/selling/doctype/customer/customer.py +108,Please mention the Lead Name in Lead {0},Harap sebutkan Nama Prospek di Prospek {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Tanggal mulai harus kurang dari tanggal akhir untuk Item {0}
DocType: Item,"Example: ABCD.#####
If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Contoh:. ABCD ##### 
 Jika seri diatur dan Nomor Seri tidak disebutkan dalam transaksi, maka nomor seri otomatis akan dibuat berdasarkan seri ini. Jika Anda ingin selalu menetapkan Nomor Seri untuk item ini, biarkan kosong."
DocType: Upload Attendance,Upload Attendance,Unggah Kehadiran
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +535,BOM and Manufacturing Quantity are required,BOM dan Kuantitas Manufaktur diperlukan
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Rentang Ageing 2
DocType: SG Creation Tool Course,Max Strength,Max Kekuatan
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Menginstal preset
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +67,No Delivery Note selected for Customer {},Tidak ada Catatan Pengiriman yang dipilih untuk Pelanggan {}
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,BOM diganti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Select Items based on Delivery Date,Pilih Item berdasarkan Tanggal Pengiriman
DocType: Grant Application,Has any past Grant Record,Memiliki Record Grant masa lalu
,Sales Analytics,Analitika Penjualan
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +119,Available {0},Tersedia {0}
,Prospects Engaged But Not Converted,Prospek Terlibat Tapi Tidak Dikonversi
DocType: Manufacturing Settings,Manufacturing Settings,Pengaturan manufaktur
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Mengatur Email
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Ponsel Tidak
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Entrikan mata uang default di Perusahaan Guru
DocType: Stock Entry Detail,Stock Entry Detail,Rincian Entri Persediaan
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Pengingat Harian
DocType: Products Settings,Home Page is Products,Home Page adalah Produk
,Asset Depreciation Ledger,Aset Penyusutan Ledger
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +88,Tax Rule Conflicts with {0},Aturan pajak Konflik dengan {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,New Account Name
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Biaya Bahan Baku Disediakan
DocType: Selling Settings,Settings for Selling Module,Pengaturan untuk Jual Modul
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Layanan Pelanggan
DocType: BOM,Thumbnail,Kuku ibu jari
DocType: Item Customer Detail,Item Customer Detail,Rincian Barang Pelanggan
apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Tawarkan Lowongan Kerja kepada Calon
DocType: Notification Control,Prompt for Email on Submission of,Minta Email untuk Pengiriman
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Jumlah cuti dialokasikan lebih dari hari pada periode
DocType: Land Unit,Linked Soil Analysis,Analisis Tanah Terkait
DocType: Pricing Rule,Percentage,Persentase
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Barang {0} harus barang persediaan
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Standar Gudang Work In Progress
apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Pengaturan default untuk transaksi akuntansi.
DocType: Maintenance Visit,MV,MV
DocType: Restaurant,Default Tax Template,Template Pajak Default
DocType: Fees,Student Details,Rincian siswa
DocType: Purchase Invoice Item,Stock Qty,Jumlah Persediaan
DocType: Employee Loan,Repayment Period in Months,Periode pembayaran di Bulan
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Kesalahan: Tidak id valid?
DocType: Naming Series,Update Series Number,Perbarui Nomor Seri
DocType: Account,Equity,Modal
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: jenis akun 'Laba Rugi' {2} tidak diperbolehkan di Entri Awal
DocType: Sales Order,Printing Details,Detai Print dan Cetak
DocType: Task,Closing Date,Tanggal Penutupan
DocType: Sales Order Item,Produced Quantity,Jumlah Diproduksi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Insinyur
DocType: Journal Entry,Total Amount Currency,Jumlah Total Mata Uang
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Cari Barang Sub Assembly
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Item Code dibutuhkan pada Row ada {0}
DocType: GST Account,SGST Account,Akun SGST
apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Pergi ke item
DocType: Sales Partner,Partner Type,Tipe Mitra/Partner
DocType: Purchase Taxes and Charges,Actual,Aktual
DocType: Restaurant Menu,Restaurant Manager,Manajer restoran
DocType: Authorization Rule,Customerwise Discount,Diskon Pelanggan
apps/erpnext/erpnext/config/projects.py +41,Timesheet for tasks.,Absen untuk tugas-tugas.
DocType: Purchase Invoice,Against Expense Account,Terhadap Akun Biaya
DocType: Production Order,Production Order,Order Produksi
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +273,Installation Note {0} has already been submitted,Instalasi Catatan {0} telah Terkirim
DocType: Bank Reconciliation,Get Payment Entries,Dapatkan Entries Pembayaran
DocType: Quotation Item,Against Docname,Terhadap Docname
DocType: SMS Center,All Employee (Active),Semua Karyawan (Aktif)
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Pelanggan&gt; Grup Pelanggan&gt; Wilayah
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Lihat Sekarang
DocType: BOM,Raw Material Cost,Biaya Bahan Baku
DocType: Item Reorder,Re-Order Level,Tingkat Re-order
DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Masukkan item dan rencana jumlah yang Anda inginkan untuk meningkatkan pesanan produksi atau unduh bahan baku untuk analisis.
apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Gantt Bagan
DocType: Crop Cycle,Cycle Type,Tipe siklus
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Part-time
DocType: Employee,Applicable Holiday List,Daftar Hari Libur yang Berlaku
DocType: Employee,Cheque,Cek
DocType: Training Event,Employee Emails,Email Karyawan
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,Nomor Seri Diperbarui
apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Report Type is mandatory,Jenis Laporan adalah wajib
DocType: Item,Serial Number Series,Serial Number Series
apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Gudang adalah wajib untuk persediaan Barang {0} pada baris {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Retail & Grosir
DocType: Issue,First Responded On,Ditangani Pertama kali pada
DocType: Website Item Group,Cross Listing of Item in multiple groups,Daftar Lintas Item dalam beberapa kelompok
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Tahun Anggaran Tanggal Mulai dan Akhir Tahun Fiskal Tanggal sudah ditetapkan pada Tahun Anggaran {0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Tanggal Kliring diperbarui
apps/erpnext/erpnext/stock/doctype/batch/batch.js +138,Split Batch,Split batch
DocType: Stock Settings,Batch Identification,Identifikasi Batch
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Berhasil Direkonsiliasi
DocType: Request for Quotation Supplier,Download PDF,Unduh PDF
DocType: Production Order,Planned End Date,Tanggal Akhir Planning
apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informasi Jenis Donor.
DocType: Request for Quotation,Supplier Detail,pemasok Detil
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Kesalahan dalam rumus atau kondisi: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Nilai Tertagih Faktur
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Kriteria bobot harus menambahkan hingga 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Absensi
apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,Barang Persediaan
DocType: BOM,Materials,Material/Barang
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Jika tidak diperiksa, daftar harus ditambahkan ke setiap departemen di mana itu harus diterapkan."
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +103,Creating {0},Membuat {0}
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Sumber dan Target Gudang tidak bisa sama
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +566,Posting date and posting time is mandatory,Tanggal posting dan posting waktu adalah wajib
apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Template pajak untuk membeli transaksi.
,Item Prices,Harga Barang/Item
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,Dalam Kata-kata akan terlihat setelah Anda menyimpan Purchase Order.
DocType: Period Closing Voucher,Period Closing Voucher,Voucher Tutup Periode
DocType: Consultation,Review Details,Rincian ulasan
DocType: Dosage Form,Dosage Form,Formulir Dosis
apps/erpnext/erpnext/config/selling.py +67,Price List master.,List Master Daftar Harga
DocType: Task,Review Date,Tanggal Ulasan
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Seri untuk Entry Depreciation Aset (Entri Jurnal)
DocType: Membership,Member Since,Anggota Sejak
DocType: Purchase Invoice,Advance Payments,Uang Muka Pembayaran(Down Payment / Advance)
DocType: Purchase Taxes and Charges,On Net Total,Pada Jumlah Net Bersih
apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Nilai untuk Atribut {0} harus berada dalam kisaran {1} ke {2} dalam penambahan {3} untuk Item {4}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171,Target warehouse in row {0} must be same as Production Order,Target gudang di baris {0} harus sama dengan Orde Produksi
DocType: Restaurant Reservation,Waitlisted,Daftar tunggu
apps/erpnext/erpnext/accounts/doctype/account/account.py +124,Currency can not be changed after making entries using some other currency,Mata uang tidak dapat diubah setelah melakukan entri menggunakan beberapa mata uang lainnya
DocType: Shipping Rule,Fixed,Tetap
DocType: Vehicle Service,Clutch Plate,clutch Plat
DocType: Company,Round Off Account,Akun Pembulatan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Beban Administrasi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Konsultasi
DocType: Customer Group,Parent Customer Group,Induk Kelompok Pelanggan
DocType: Journal Entry,Subscription,Berlangganan
DocType: Purchase Invoice,Contact Email,Email Kontak
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Penciptaan Biaya Tertunda
DocType: Appraisal Goal,Score Earned,Skor Earned
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Notice Period,Masa Pemberitahuan
DocType: Asset Category,Asset Category Name,Aset Kategori Nama
apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Ini adalah wilayah akar dan tidak dapat diedit.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Nama baru Sales Person
DocType: Packing Slip,Gross Weight UOM,UOM Berat Kotor
DocType: Asset Maintenance Task,Preventive Maintenance,Pemeliharaan preventif
DocType: Delivery Note Item,Against Sales Invoice,Terhadap Faktur Penjualan
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Harap masukkan nomor seri untuk item serial
DocType: Bin,Reserved Qty for Production,Dicadangkan Jumlah Produksi
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Biarkan tidak dicentang jika Anda tidak ingin mempertimbangkan batch sambil membuat kelompok berbasis kursus.
DocType: Asset,Frequency of Depreciation (Months),Frekuensi Penyusutan (Bulan)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +501,Credit Account,Akun kredit
DocType: Landed Cost Item,Landed Cost Item,Jenis Barang Biaya Landing
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Tampilkan nilai nol
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Jumlah Kuantitas Produk yang dihasilkan dari proses manufakturing / repacking dari jumlah kuantitas bahan baku yang disediakan
DocType: Lab Test,Test Group,Grup Uji
DocType: Payment Reconciliation,Receivable / Payable Account,Piutang / Account Payable
DocType: Delivery Note Item,Against Sales Order Item,Terhadap Barang di Order Penjualan
apps/erpnext/erpnext/stock/doctype/item/item.py +680,Please specify Attribute Value for attribute {0},Silakan tentukan Atribut Nilai untuk atribut {0}
DocType: Item,Default Warehouse,Standar Gudang
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Anggaran tidak dapat diberikan terhadap Account Group {0}
DocType: Healthcare Settings,Patient Registration,Pendaftaran Pasien
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,Entrikan pusat biaya orang tua
DocType: Delivery Note,Print Without Amount,Cetak Tanpa Jumlah
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,penyusutan Tanggal
DocType: Issue,Support Team,Tim Support
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Kadaluwarsa (Dalam Days)
DocType: Appraisal,Total Score (Out of 5),Skor Total (Out of 5)
DocType: Fee Structure,FS.,FS.
DocType: Student Attendance Tool,Batch,Kumpulan
DocType: Donor,Donor Type,Jenis Donor
apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Keseimbangan
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Silahkan pilih Perusahaan
DocType: Room,Seating Capacity,Kapasitas tempat duduk
DocType: Issue,ISS-,ISS-
DocType: Lab Test Groups,Lab Test Groups,Kelompok Uji Lab
DocType: Project,Total Expense Claim (via Expense Claims),Jumlah Klaim Beban (via Klaim Beban)
DocType: GST Settings,GST Summary,Ringkasan GST
DocType: Assessment Result,Total Score,Skor total
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +116,Please set the Default Cost Center in {0} company,Harap atur Default Cost Center di {0} perusahaan
DocType: Journal Entry,Debit Note,Debit Note
DocType: Stock Entry,As per Stock UOM,Sesuai UOM Persediaan
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Tidak Kedaluwarsa
DocType: Student Log,Achievement,Pencapaian
DocType: Batch,Source Document Type,Jenis Dokumen Sumber
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Jadwal kursus berikut telah dibuat
DocType: Journal Entry,Total Debit,Jumlah Debit
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Gudang bawaan Selesai Stok Barang
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Sales Person
apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Anggaran dan Pusat Biaya
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Beberapa modus pembayaran default tidak diperbolehkan
apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,Untuk
,Appointment Analytics,Penunjukan Analytics
DocType: Vehicle Service,Half Yearly,Setengah Tahunan
DocType: Lead,Blog Subscriber,Pelanggan Blog
DocType: Guardian,Alternate Number,Jumlah alternatif
DocType: Healthcare Settings,Consultations in valid days,Konsultasi di hari yang benar
DocType: Assessment Plan Criteria,Maximum Score,Skor maksimum
apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Buat aturan untuk membatasi transaksi berdasarkan nilai-nilai.
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,No. Roll Kelompok
DocType: Batch,Manufacturing Date,Tanggal pembuatan
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Penciptaan Biaya Gagal
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Biarkan kosong jika Anda membuat kelompok siswa per tahun
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Jika dicentang, total ada. dari Hari Kerja akan mencakup libur, dan ini akan mengurangi nilai Gaji Per Hari"
DocType: Purchase Invoice,Total Advance,Jumlah Uang Muka
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Ubah Kode Template
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Jangka Tanggal Akhir tidak dapat lebih awal dari tanggal Term Start. Perbaiki tanggal dan coba lagi.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,"Jumlah ""Penawaran"""
,BOM Stock Report,Laporan Persediaan BOM
DocType: Stock Reconciliation Item,Quantity Difference,Perbedaan Kuantitas
DocType: Employee Advance,EA-,EA-
apps/erpnext/erpnext/config/hr.py +320,Processing Payroll,Pengolahan Payroll
DocType: Opportunity Item,Basic Rate,Tarif Dasar
DocType: GL Entry,Credit Amount,Jumlah kredit
DocType: Cheque Print Template,Signatory Position,Posisi penandatangan
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Set as Lost,Set as Hilang/Kalah
DocType: Timesheet,Total Billable Hours,Total Jam Ditagih
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Pembayaran Penerimaan Catatan
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Hal ini didasarkan pada transaksi terhadap pelanggan ini. Lihat timeline di bawah untuk rincian
DocType: Company,Credit Days Based On,Hari Kredit Berdasarkan
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Row {0}: Dialokasikan jumlah {1} harus kurang dari atau sama dengan jumlah entri Pembayaran {2}
DocType: Program Enrollment Tool,New Academic Term,Istilah Akademik Baru
,Course wise Assessment Report,Laporan Penilaian yang tepat
DocType: Tax Rule,Tax Rule,Aturan pajak
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Pertahankan Tarif Sama Sepanjang Siklus Penjualan
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Rencana waktu log luar Jam Kerja Workstation.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +92,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} tidak memiliki Jadwal Dokter. Tambahkan di master dokter
apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Pelanggan di Antrian
DocType: Driver,Issuing Date,Tanggal penerbitan
DocType: Student,Nationality,Kebangsaan
,Items To Be Requested,Items Akan Diminta
DocType: Purchase Order,Get Last Purchase Rate,Dapatkan Terakhir Purchase Rate
DocType: Company,Company Info,Info Perusahaan
apps/erpnext/erpnext/accounts/page/pos/pos.js +1375,Select or add new customer,Pilih atau menambahkan pelanggan baru
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +179,Cost center is required to book an expense claim,pusat biaya diperlukan untuk memesan klaim biaya
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Penerapan Dana (Aset)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Hal ini didasarkan pada kehadiran Karyawan ini
DocType: Assessment Result,Summary,Ringkasan
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Mark Kehadiran
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +495,Debit Account,Akun Debit
DocType: Fiscal Year,Year Start Date,Tanggal Mulai Tahun
DocType: Attendance,Employee Name,Nama Karyawan
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Item Item Pemesanan Restoran
DocType: Purchase Invoice,Rounded Total (Company Currency),Rounded Jumlah (Perusahaan Mata Uang)
apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Cannot covert to Group because Account Type is selected.,Tidak dapat mengkonversi ke Grup karena Tipe Akun dipilih.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} telah diubah. Silahkan refresh.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Menghentikan pengguna dari membuat Aplikasi Leave pada hari-hari berikutnya.
DocType: Asset Maintenance Team,Maintenance Team Members,Anggota Tim Pemeliharaan
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Jumlah pembelian
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Pemasok Quotation {0} dibuat
apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Akhir Tahun tidak boleh sebelum Mulai Tahun
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Employee Benefits,Manfaat Karyawan
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packed quantity must equal quantity for Item {0} in row {1},Dikemas kuantitas harus sama kuantitas untuk Item {0} berturut-turut {1}
DocType: Production Order,Manufactured Qty,Qty Diproduksi
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Faktur dibuat
DocType: Asset,Out of Order,Habis
DocType: Purchase Receipt Item,Accepted Quantity,Qty Diterima
apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},Silahkan mengatur default Liburan Daftar Karyawan {0} atau Perusahaan {1}
apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0}: {1} tidak ada
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Pilih Batch Numbers
apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Tagihan diajukan ke Pelanggan.
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Proyek Id
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +532,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Row ada {0}: Jumlah dapat tidak lebih besar dari Pending Jumlah terhadap Beban Klaim {1}. Pending Jumlah adalah {2}
DocType: Assessment Plan,Schedule,Jadwal
DocType: Account,Parent Account,Rekening Induk
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,Tersedia
DocType: Quality Inspection Reading,Reading 3,Membaca 3
,Hub,Pusat
DocType: GL Entry,Voucher Type,Voucher Type
apps/erpnext/erpnext/accounts/page/pos/pos.js +1707,Price List not found or disabled,Daftar Harga tidak ditemukan atau dinonaktifkan
DocType: Student Applicant,Approved,Disetujui
DocType: Pricing Rule,Price,Harga
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',Karyawan lega pada {0} harus ditetapkan sebagai 'Kiri'
DocType: Hub Settings,Last Sync On,Sinkron Terakhir Aktif
DocType: Guardian,Guardian,Wali
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Penilaian {0} telah dibuat untuk karyawan {1} dalam rentang tanggal tertentu
DocType: Academic Term,Education,Pendidikan
apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,Del
DocType: Selling Settings,Campaign Naming By,Penamaan Kampanye Promosi dengan
DocType: Employee,Current Address Is,Alamat saat ini adalah
apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Target Penjualan Bulanan
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,diubah
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Opsional. Set mata uang default perusahaan, jika tidak ditentukan."
DocType: Sales Invoice,Customer GSTIN,Pelanggan GSTIN
DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,Daftar penyakit yang terdeteksi di lapangan. Bila dipilih maka secara otomatis akan menambahkan daftar tugas untuk mengatasi penyakit tersebut
DocType: Asset Repair,Repair Status,Status perbaikan
apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Pencatatan Jurnal akuntansi.
DocType: Delivery Note Item,Available Qty at From Warehouse,Jumlah yang tersedia di Gudang Dari
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +327,Please select Employee Record first.,Silakan pilih Rekam Karyawan terlebih dahulu.
DocType: POS Profile,Account for Change Amount,Akun untuk Perubahan Jumlah
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +215,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Row {0}: Partai / Rekening tidak sesuai dengan {1} / {2} di {3} {4}
DocType: Maintenance Team Member,Maintenance Team Member,Anggota Tim Pemeliharaan
DocType: Agriculture Analysis Criteria,Soil Analysis,Analisis tanah
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kode Kursus:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Masukan Entrikan Beban Akun
DocType: Account,Stock,Persediaan
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Dokumen Referensi Type harus menjadi salah satu Purchase Order, Faktur Pembelian atau Journal Entri"
DocType: Employee,Current Address,Alamat saat ini
DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Jika item adalah varian dari item lain maka deskripsi, gambar, harga, pajak dll akan ditetapkan dari template kecuali secara eksplisit ditentukan"
DocType: Serial No,Purchase / Manufacture Details,Detail Pembelian / Produksi
DocType: Assessment Group,Assessment Group,Grup penilaian
apps/erpnext/erpnext/config/stock.py +325,Batch Inventory,Batch Persediaan
DocType: Employee,Contract End Date,Tanggal Kontrak End
DocType: Sales Order,Track this Sales Order against any Project,Melacak Order Penjualan ini terhadap Proyek apapun
DocType: Sales Invoice Item,Discount and Margin,Diskon dan Margin
DocType: Lab Test,Prescription,Resep
DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,Tarik Order penjualan (pending untuk memberikan) berdasarkan kriteria di atas
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Tidak Tersedia
DocType: Pricing Rule,Min Qty,Min Qty
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Nonaktifkan Template
DocType: GL Entry,Transaction Date,Transaction Tanggal
DocType: Production Plan Item,Planned Qty,Qty Planning
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total Pajak
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +187,For Quantity (Manufactured Qty) is mandatory,Untuk Quantity (Diproduksi Qty) adalah wajib
DocType: Stock Entry,Default Target Warehouse,Standar Sasaran Gudang
DocType: Purchase Invoice,Net Total (Company Currency),Jumlah Bersih (Perusahaan Mata Uang)
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Akhir Tahun Tanggal tidak dapat lebih awal dari Tahun Tanggal Mulai. Perbaiki tanggal dan coba lagi.
DocType: Notification Control,Purchase Receipt Message,Pesan Nota Penerimaan
DocType: BOM,Scrap Items,scrap Produk
DocType: Production Order,Actual Start Date,Tanggal Mulai Aktual
DocType: Sales Order,% of materials delivered against this Sales Order,% Dari materi yang Terkirim terhadap Sales Order ini
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Tetapkan mode pembayaran default
DocType: Grant Application,Withdrawn,pendiam
DocType: Hub Settings,Hub Settings,Pengaturan Hub
DocType: Project,Gross Margin %,Gross Margin%
DocType: BOM,With Operations,Dengan Operasi
apps/erpnext/erpnext/accounts/party.py +262,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Entri Akuntansi telah dibuat dalam mata uang {0} untuk perusahaan {1}. Silakan pilih akun piutang atau hutang dengan mata uang {0}.
DocType: Asset,Is Existing Asset,Apakah ada Asset
DocType: Salary Detail,Statistical Component,Komponen statistik
DocType: Warranty Claim,If different than customer address,Jika berbeda dari alamat pelanggan
DocType: Purchase Invoice,Without Payment of Tax,Tanpa Pembayaran Pajak
DocType: BOM Operation,BOM Operation,BOM Operation
apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Pemenuhan
DocType: Purchase Taxes and Charges,On Previous Row Amount,Pada Sebelumnya Row Jumlah
DocType: Item,Has Expiry Date,Memiliki Tanggal Kedaluwarsa
apps/erpnext/erpnext/assets/doctype/asset/asset.js +269,Transfer Asset,pengalihan Aset
DocType: POS Profile,POS Profile,POS Profil
DocType: Training Event,Event Name,Nama acara
DocType: Physician,Phone (Office),Telepon (Kantor)
apps/erpnext/erpnext/hooks.py +151,Admission,Penerimaan
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Penerimaan untuk {0}
apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Musiman untuk menetapkan anggaran, target dll"
DocType: Supplier Scorecard Scoring Variable,Variable Name,Nama variabel
apps/erpnext/erpnext/stock/get_item_details.py +142,"Item {0} is a template, please select one of its variants","Item {0} adalah template, silahkan pilih salah satu variannya"
DocType: Asset,Asset Category,Aset Kategori
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Gaji bersih yang belum dapat negatif
DocType: Purchase Order,Advance Paid,Pembayaran Dimuka (Advance)
DocType: Item,Item Tax,Pajak Stok Barang
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +872,Material to Supplier,Bahan untuk Supplier
DocType: Soil Texture,Loamy Sand,Pasir Loamy
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +594,Excise Invoice,Cukai Faktur
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}% muncul lebih dari sekali
DocType: Expense Claim,Employees Email Id,ID Email Karyawan
DocType: Employee Attendance Tool,Marked Attendance,Absensi Terdaftar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Piutang Lancar
apps/erpnext/erpnext/config/selling.py +292,Send mass SMS to your contacts,Kirim SMS massal ke kontak Anda
DocType: Patient,A Positive,Positif
DocType: Program,Program Name,Program Nama
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Pertimbangkan Pajak atau Biaya untuk
DocType: Driver,Driving License Category,Kategori Lisensi Mengemudi
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Qty Aktual wajib diisi
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +88,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} saat ini memiliki posisi Scorecard Pemasok {1}, Pesanan Pembelian untuk pemasok ini harus dikeluarkan dengan hati-hati."
DocType: Asset Maintenance Team,Asset Maintenance Team,Tim Pemeliharaan Aset
DocType: Employee Loan,Loan Type,Jenis pinjaman
DocType: Scheduling Tool,Scheduling Tool,Alat penjadwalan
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Kartu Kredit
DocType: BOM,Item to be manufactured or repacked,Item yang akan diproduksi atau dikemas ulang
DocType: Employee Education,Major/Optional Subjects,Mayor / Opsional Subjek
DocType: Sales Invoice Item,Drop Ship,Pengiriman Drop Ship
DocType: Driver,Suspended,Tergantung
DocType: Training Event,Attendees,peserta
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Di sini Anda dapat mempertahankan rincian keluarga seperti nama dan pekerjaan orang tua, pasangan dan anak-anak"
DocType: Academic Term,Term End Date,Istilah Tanggal Akhir
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Pajak dan Biaya Dikurangi (Perusahaan Mata Uang)
DocType: Item Group,General Settings,Pengaturan Umum
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Dari Mata dan Mata Uang Untuk tidak bisa sama
DocType: Stock Entry,Repack,Repack
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Anda harus menyimpan formulir sebelum melanjutkan
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Silahkan pilih Perusahaan terlebih dahulu
DocType: Item Attribute,Numeric Values,Nilai numerik
apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Pasang Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js +43,Stock Levels,Tingkat Persediaan
DocType: Customer,Commission Rate,Tingkat Komisi
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Menciptakan {0} scorecard untuk {1} antara:
apps/erpnext/erpnext/stock/doctype/item/item.js +473,Make Variant,Buat Varian
apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Blok permintaan cuti per departemen.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +144,"Payment Type must be one of Receive, Pay and Internal Transfer","Jenis Pembayaran harus menjadi salah satu Menerima, Pay dan Internal Transfer"
apps/erpnext/erpnext/config/selling.py +179,Analytics,Analytics
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +21,Cart is Empty,Cart adalah Kosong
DocType: Vehicle,Model,Model
DocType: Production Order,Actual Operating Cost,Biaya Operasi Aktual
DocType: Payment Entry,Cheque/Reference No,Cek / Referensi Tidak ada
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py +81,Root cannot be edited.,Root tidak dapat diedit.
DocType: Item,Units of Measure,Satuan ukur
DocType: Manufacturing Settings,Allow Production on Holidays,Izinkan Produksi di hari libur
DocType: Sales Order,Customer's Purchase Order Date,Tanggal Order Pembelian Pelanggan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Modal / Saham
DocType: Shopping Cart Settings,Show Public Attachments,Tampilkan Lampiran Umum
DocType: Packing Slip,Package Weight Details,Paket Berat Detail
DocType: Restaurant Reservation,Reservation Time,Waktu Reservasi
DocType: Payment Gateway Account,Payment Gateway Account,Pembayaran Rekening Gateway
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Setelah selesai pembayaran mengarahkan pengguna ke halaman yang dipilih.
DocType: Company,Existing Company,Perusahaan yang ada
DocType: Healthcare Settings,Result Emailed,Hasil Diemailkan
apps/erpnext/erpnext/controllers/buying_controller.py +87,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Kategori Pajak telah diubah menjadi ""Total"" karena semua barang adalah barang non-persediaan"
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Silakan pilih file csv
DocType: Student Leave Application,Mark as Present,Tandai sebagai Hadir
DocType: Supplier Scorecard,Indicator Color,Indikator Warna
DocType: Purchase Order,To Receive and Bill,Untuk Diterima dan Ditagih
apps/erpnext/erpnext/controllers/buying_controller.py +455,Row #{0}: Reqd by Date cannot be before Transaction Date,Baris # {0}: Reqd by Date tidak boleh sebelum Tanggal Transaksi
apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Produk Pilihan
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Perancang
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Syarat dan Ketentuan Template
DocType: Serial No,Delivery Details,Detail Pengiriman
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495,Cost Center is required in row {0} in Taxes table for type {1},Biaya Pusat diperlukan dalam baris {0} dalam tabel Pajak untuk tipe {1}
DocType: Program,Program Code,Kode Program
DocType: Terms and Conditions,Terms and Conditions Help,Syarat dan Ketentuan Bantuan
,Item-wise Purchase Register,Stok Barang-bijaksana Pembelian Register
DocType: Driver,Expiry Date,Tanggal Berakhir
DocType: Healthcare Settings,Employee name and designation in print,Nama karyawan dan sebutan di cetak
,accounts-browser,account-browser
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Silahkan pilih Kategori terlebih dahulu
apps/erpnext/erpnext/config/projects.py +13,Project master.,Master Proyek
apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Untuk memungkinkan penagihan lebih atau pemesanan lebih, perbarui ""Penyisihan"" di Pengaturan Persediaan atau Barang."
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Jangan menunjukkan simbol seperti $ etc sebelah mata uang.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +491, (Half Day),(Setengah Hari)
DocType: Payment Term,Credit Days,Hari Kredit
apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Membuat Batch Mahasiswa
DocType: Fee Schedule,FRQ.,FRQ.
DocType: Leave Type,Is Carry Forward,Apakah Carry Teruskan
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,Get Items from BOM,Dapatkan item dari BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Hari Masa Tenggang
apps/erpnext/erpnext/controllers/accounts_controller.py +620,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Posting Tanggal harus sama dengan tanggal pembelian {1} aset {2}
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Periksa ini jika Siswa berada di Institute&#39;s Hostel.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Cukup masukkan Penjualan Pesanan dalam tabel di atas
,Stock Summary,Ringkasan Persediaan
apps/erpnext/erpnext/config/assets.py +50,Transfer an asset from one warehouse to another,Mentransfer aset dari satu gudang ke yang lain
DocType: Vehicle,Petrol,Bensin
apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Bill of Material
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Partai Jenis dan Partai diperlukan untuk Piutang / Hutang akun {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref Tanggal
DocType: Employee,Reason for Leaving,Alasan Meninggalkan
DocType: BOM Operation,Operating Cost(Company Currency),Biaya operasi (Perusahaan Mata Uang)
DocType: Employee Loan Application,Rate of Interest,Tingkat Tujuan
DocType: Expense Claim Detail,Sanctioned Amount,Jumlah sanksi
DocType: Item,Shelf Life In Days,Shelf Life In Days
DocType: GL Entry,Is Opening,Apakah Membuka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +194,Row {0}: Debit entry can not be linked with a {1},Baris {0}: Debit masuk tidak dapat dihubungkan dengan {1}
DocType: Journal Entry,Subscription Section,Bagian Langganan
apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account {0} does not exist,Akun {0} tidak ada
DocType: Training Event,Training Program,Program pelatihan
DocType: Account,Cash,Kas
DocType: Employee,Short biography for website and other publications.,Biografi singkat untuk website dan publikasi lainnya.
