DocType: Accounting Period,Period Name,Ime perioda
DocType: Employee,Salary Mode,Plaća način
apps/erpnext/erpnext/public/js/hub/marketplace.js +109,Register,Registrujte se
DocType: Patient,Divorced,Rastavljen
DocType: Support Settings,Post Route Key,Post Route Key
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Dozvolite Stavka treba dodati više puta u transakciji
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Odustani Materijal {0} Posjeti prije otkazivanja ova garancija potraživanje
apps/erpnext/erpnext/config/education.py +118,Assessment Reports,Izveštaji o proceni
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Consumer Products
DocType: Supplier Scorecard,Notify Supplier,Obavijestiti dobavljača
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js +52,Please select Party Type first,Molimo prvo odaberite Party Tip
DocType: Item,Customer Items,Customer Predmeti
DocType: Project,Costing and Billing,Cijena i naplata
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +43,Advance account currency should be same as company currency {0},Advance valuta valute mora biti ista kao valuta kompanije {0}
apps/erpnext/erpnext/accounts/doctype/account/account.py +55,Account {0}: Parent account {1} can not be a ledger,Konto {0}: Nadređeni konto {1} Ne može biti knjiga
DocType: Item,Publish Item to hub.erpnext.com,Objavite stavku da hub.erpnext.com
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +271,Cannot find active Leave Period,Ne mogu pronaći aktivni period otpusta
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +22,Evaluation,procjena
DocType: Item,Default Unit of Measure,Zadana mjerna jedinica
DocType: SMS Center,All Sales Partner Contact,Svi kontakti distributera
DocType: Department,Leave Approvers,Ostavite odobravateljima
DocType: Employee,Bio / Cover Letter,Bio / Cover Letter
DocType: Patient Encounter,Investigations,Istrage
DocType: Restaurant Order Entry,Click Enter To Add,Kliknite Enter za dodavanje
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +29,"Missing value for Password, API Key or Shopify URL","Nedostajuća vrijednost za lozinku, API ključ ili Shopify URL"
DocType: Employee,Rented,Iznajmljuje
apps/erpnext/erpnext/public/js/setup_wizard.js +243,All Accounts,Svi računi
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +15,Cannot transfer Employee with status Left,Ne može preneti zaposlenog sa statusom Levo
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Zaustavila proizvodnju Naredba se ne može otkazati, odčepiti to prvi koji će otkazati"
DocType: Vehicle Service,Mileage,kilometraža
apps/erpnext/erpnext/assets/doctype/asset/asset.js +338,Do you really want to scrap this asset?,Da li zaista želite da ukine ove imovine?
DocType: Drug Prescription,Update Schedule,Raspored ažuriranja
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Izaberite snabdjevač
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +26,Show Employee,Show Employee
DocType: Exchange Rate Revaluation Account,New Exchange Rate,Novi kurs
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +38,Currency is required for Price List {0},Valuta je potreban za Cjenovnik {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Hoće li biti izračunata u transakciji.
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-YYYY.-
DocType: Purchase Order,Customer Contact,Kontakt kupca
DocType: Patient Appointment,Check availability,Provjera dostupnosti
DocType: Retention Bonus,Bonus Payment Date,Datum isplate bonusa
DocType: Employee,Job Applicant,Posao podnositelj
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Ovo se zasniva na transakcije protiv tog dobavljača. Pogledajte vremenski okvir ispod za detalje
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Procent prekomerne proizvodnje za radni nalog
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +362,Legal,Pravni
DocType: Delivery Note,Transport Receipt Date,Datum prijema prevoza
DocType: Shopify Settings,Sales Order Series,Narudžbe serije prodaje
DocType: Vital Signs,Tongue,Jezik
apps/erpnext/erpnext/hr/utils.py +221,"More than one selection for {0} not \
			allowed",Više od jedne selekcije za {0} nije dozvoljeno
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +204,Actual type tax cannot be included in Item rate in row {0},Stvarni tip porez ne može biti uključen u stopu stavka u nizu {0}
DocType: Allowed To Transact With,Allowed To Transact With,Dozvoljeno za transakciju
DocType: Bank Guarantee,Customer,Kupci
DocType: Purchase Receipt Item,Required By,Potrebna Do
DocType: Delivery Note,Return Against Delivery Note,Vratiti protiv Isporuka Napomena
DocType: Asset Category,Finance Book Detail,Knjiga finansija Detail
DocType: Purchase Order,% Billed,Naplaćeno%
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +41,Exchange Rate must be same as {0} {1} ({2}),Tečajna lista moraju biti isti kao {0} {1} ({2})
DocType: Employee Tax Exemption Declaration,HRA Exemption,HRA izuzeće
DocType: Sales Invoice,Customer Name,Naziv kupca
DocType: Vehicle,Natural Gas,prirodni gas
apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +63,Bank account cannot be named as {0},Žiro račun ne može biti imenovan kao {0}
DocType: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA po plati strukturi
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Heads (ili grupe) protiv kojih Računovodstvo unosi se izrađuju i sredstva se održavaju.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +197,Outstanding for {0} cannot be less than zero ({1}),Izvanredna za {0} ne može biti manji od nule ( {1} )
apps/erpnext/erpnext/public/js/controllers/transaction.js +809,Service Stop Date cannot be before Service Start Date,Servisni datum zaustavljanja ne može biti pre početka usluge
DocType: Manufacturing Settings,Default 10 mins,Uobičajeno 10 min
DocType: Leave Type,Leave Type Name,Ostavite ime tipa
apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Pokaži otvoren
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +163,Series Updated Successfully,Serija Updated uspješno
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Provjeri
apps/erpnext/erpnext/controllers/accounts_controller.py +772,{0} in row {1},{0} u redu {1}
DocType: Asset Finance Book,Depreciation Start Date,Datum početka amortizacije
DocType: Pricing Rule,Apply On,Primjeni na
DocType: Item Price,Multiple Item prices.,Više cijene stavke.
,Purchase Order Items To Be Received,Narudžbenica Proizvodi treba primiti
DocType: SMS Center,All Supplier Contact,Svi kontakti dobavljača
DocType: Support Settings,Support Settings,podrška Postavke
apps/erpnext/erpnext/projects/doctype/project/project.py +84,Expected End Date can not be less than Expected Start Date,Očekivani Završni datum ne može biti manji od očekivanog datuma Početak
DocType: Amazon MWS Settings,Amazon MWS Settings,Amazon MWS Settings
apps/erpnext/erpnext/utilities/transaction_base.py +115,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Rate moraju biti isti kao {1}: {2} ({3} / {4})
,Batch Item Expiry Status,Batch Stavka Status isteka
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +160,Bank Draft,Bank Nacrt
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-YYYY.-
DocType: Mode of Payment Account,Mode of Payment Account,Način plaćanja računa
apps/erpnext/erpnext/config/healthcare.py +8,Consultation,Konsultacije
DocType: Accounts Settings,Show Payment Schedule in Print,Prikaži raspored plaćanja u štampanju
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +21,Sales and Returns,Prodaja i povratak
apps/erpnext/erpnext/stock/doctype/item/item.js +58,Show Variants,Show Varijante
DocType: Academic Term,Academic Term,akademski Term
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Kategorija podnošenja poreza na oporezivanje zaposlenih
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,materijal
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +71,Making website,Pravljenje web stranice
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +58,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
			amount and previous claimed amount",Maksimalna korist zaposlenog {0} prelazi {1} za sumu {2} proporcionalne komponente komponente \ iznos i iznos prethodne tražene
DocType: Opening Invoice Creation Tool Item,Quantity,Količina
,Customers Without Any Sales Transactions,Kupci bez prodajnih transakcija
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +590,Accounts table cannot be blank.,Računi stol ne može biti prazan.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +164,Loans (Liabilities),Zajmovi (pasiva)
DocType: Patient Encounter,Encounter Time,Vrijeme susreta
DocType: Staffing Plan Detail,Total Estimated Cost,Ukupni procijenjeni troškovi
DocType: Employee Education,Year of Passing,Tekuća godina
DocType: Routing,Routing Name,Ime rutiranja
DocType: Item,Country of Origin,Zemlja porijekla
DocType: Soil Texture,Soil Texture Criteria,Kriterijumi za teksturu tla
apps/erpnext/erpnext/templates/includes/product_page.js +34,In Stock,U Stock
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Primarni kontakt podaci
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,otvorena pitanja
DocType: Production Plan Item,Production Plan Item,Proizvodnja plan artikla
apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,User {0} is already assigned to Employee {1},Korisnik {0} već dodijeljena zaposlenika {1}
DocType: Lab Test Groups,Add new line,Dodajte novu liniju
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Zdravstvena zaštita
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Kašnjenje u plaćanju (Dani)
DocType: Payment Terms Template Detail,Payment Terms Template Detail,Detail Template Template
DocType: Hotel Room Reservation,Guest Name,Ime gosta
DocType: Delivery Note,Issue Credit Note,Izdajte kreditnu poruku
DocType: Lab Prescription,Lab Prescription,Lab recept
,Delay Days,Dani odlaganja
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Servis rashodi
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1002,Serial Number: {0} is already referenced in Sales Invoice: {1},Serijski broj: {0} je već spomenut u prodaje Faktura: {1}
DocType: Bank Statement Transaction Invoice Item,Invoice,Faktura
DocType: Purchase Invoice Item,Item Weight Details,Detaljna težina stavke
DocType: Asset Maintenance Log,Periodicity,Periodičnost
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Fiskalna godina {0} je potrebno
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Minimalno rastojanje između redova biljaka za optimalan rast
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Obrana
DocType: Salary Component,Abbr,Skraćeni naziv
DocType: Appraisal Goal,Score (0-5),Ocjena (0-5)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +257,Row {0}: {1} {2} does not match with {3},Row {0}: {1} {2} ne odgovara {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +78,Row # {0}:,Row # {0}:
DocType: Timesheet,Total Costing Amount,Ukupno Costing iznos
DocType: Delivery Note,Vehicle No,Ne vozila
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +172,Please select Price List,Molimo odaberite Cjenik
DocType: Accounts Settings,Currency Exchange Settings,Postavke razmjene valuta
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Isplata dokument je potrebno za završetak trasaction
DocType: Work Order Operation,Work In Progress,Radovi u toku
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Molimo izaberite datum
DocType: Item Price,Minimum Qty ,Minimalni količina
DocType: Finance Book,Finance Book,Finansijska knjiga
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-YYYY.-
DocType: Daily Work Summary Group,Holiday List,Lista odmora
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Accountant,Računovođa
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +55,Selling Price List,Prodajni cjenik
DocType: Patient,Tobacco Current Use,Upotreba duvana
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +62,Selling Rate,Prodajna stopa
DocType: Cost Center,Stock User,Stock korisnika
DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
DocType: Delivery Stop,Contact Information,Kontakt informacije
DocType: Company,Phone No,Telefonski broj
DocType: Delivery Trip,Initial Email Notification Sent,Poslato je prvo obaveštenje o e-mailu
DocType: Bank Statement Settings,Statement Header Mapping,Mapiranje zaglavlja izjave
,Sales Partners Commission,Prodaja Partneri komisija
apps/erpnext/erpnext/hr/doctype/employee/employee.py +25,Please setup Employee Naming System in Human Resource &gt; HR Settings,Molimo da podesite sistem imenovanja zaposlenih u ljudskim resursima&gt; HR Settings
DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
DocType: Purchase Invoice,Rounding Adjustment,Prilagođavanje zaokruživanja
apps/erpnext/erpnext/setup/doctype/company/company.py +50,Abbreviation cannot have more than 5 characters,Skraćeni naziv ne može imati više od 5 znakova
DocType: Amazon MWS Settings,AU,AU
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +7,Payment Request,Plaćanje Upit
apps/erpnext/erpnext/config/accounts.py +56,To view logs of Loyalty Points assigned to a Customer.,Da biste videli evidencije o Lojalnim Tačkama dodeljenim Korisniku.
DocType: Asset,Value After Depreciation,Vrijednost Nakon Amortizacija
DocType: Student,O+,O +
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,povezan
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +46,Attendance date can not be less than employee's joining date,Datum prisustvo ne može biti manji od datuma pristupanja zaposlenog
DocType: Grading Scale,Grading Scale Name,Pravilo Scale Ime
apps/erpnext/erpnext/public/js/hub/marketplace.js +148,Add Users to Marketplace,Dodajte korisnike na Marketplace
apps/erpnext/erpnext/accounts/doctype/account/account.js +37,This is a root account and cannot be edited.,To jekorijen račun i ne može se mijenjati .
DocType: Sales Invoice,Company Address,Company Adresa
DocType: BOM,Operations,Operacije
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Ne mogu postaviti odobrenje na temelju popusta za {0}
DocType: Subscription,Subscription Start Date,Datum početka pretplate
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,Podrazumevani računi potraživanja koji će se koristiti ako nisu postavljeni u Pacijentu da rezervišu troškove naplate.
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Priložiti .csv datoteku s dvije kolone, jedan za stari naziv i jedna za novo ime"
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +195,From Address 2,Od adrese 2
apps/erpnext/erpnext/accounts/utils.py +74,{0} {1} not in any active Fiscal Year.,{0} {1} ne u bilo kojem aktivnom fiskalne godine.
DocType: Packed Item,Parent Detail docname,Roditelj Detalj docname
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Referenca: {0}, Šifra: {1} i kupaca: {2}"
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +360,{0} {1} is not present in the parent company,{0} {1} nije prisutan u matičnoj kompaniji
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +215,Trial Period End Date Cannot be before Trial Period Start Date,Krajnji datum probnog perioda ne može biti pre početka probnog perioda
apps/erpnext/erpnext/utilities/user_progress.py +146,Kg,kg
DocType: Tax Withholding Category,Tax Withholding Category,Kategorija za oduzimanje poreza
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py +23,Cancel the journal entry {0} first,Prvo otpustite unos teksta {0}
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +113,BOM is not specified for subcontracting item {0} at row {1},BOM nije naveden za stavku podizvođača {0} na redu {1}
DocType: Vital Signs,Reflexes,Refleksi
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Rezultat je podnet
DocType: Item Attribute,Increment,Prirast
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,Vremenski razmak
apps/erpnext/erpnext/templates/pages/search_help.py +13,Help Results for,Pomoć rezultata za
apps/erpnext/erpnext/public/js/stock_analytics.js +58,Select Warehouse...,Odaberite Warehouse ...
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Oglašavanje
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Ista firma je ušao više od jednom
DocType: Patient,Married,Oženjen
apps/erpnext/erpnext/accounts/party.py +42,Not permitted for {0},Nije dozvoljeno za {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +617,Get items from,Get stavke iz
DocType: Price List,Price Not UOM Dependant,Cena nije UOM zavisna
DocType: Purchase Invoice,Apply Tax Withholding Amount,Primijeniti iznos poreznog štednje
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +538,Stock cannot be updated against Delivery Note {0},Dionica ne može biti obnovljeno protiv isporuke Napomena {0}
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +124,Total Amount Credited,Ukupan iznos kredita
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Proizvod {0}
apps/erpnext/erpnext/templates/generators/item_group.html +33,No items listed,No stavke navedene
DocType: Asset Repair,Error Description,Opis greške
DocType: Payment Reconciliation,Reconcile,pomiriti
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Trgovina prehrambenom robom
DocType: Quality Inspection Reading,Reading 1,Čitanje 1
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,mirovinskim fondovima
DocType: Exchange Rate Revaluation Account,Gain/Loss,Dobit / gubitak
DocType: Crop,Perennial,Višegodišnje
DocType: Patient Appointment,Procedure,Procedura
DocType: Accounts Settings,Use Custom Cash Flow Format,Koristite Custom Flow Flow Format
DocType: SMS Center,All Sales Person,Svi prodavači
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Mjesečna distribucija ** će Vam pomoći distribuirati budžeta / Target preko mjeseca ako imate sezonalnost u vaše poslovanje.
apps/erpnext/erpnext/accounts/page/pos/pos.js +1768,Not items found,Nije pronađenim predmetima
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267,Salary Structure Missing,Plaća Struktura Missing
DocType: Lead,Person Name,Ime osobe
DocType: Sales Invoice Item,Sales Invoice Item,Stavka fakture prodaje
DocType: Account,Credit,Kredit
DocType: POS Profile,Write Off Cost Center,Otpis troška
apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",npr &quot;Osnovna škola&quot; ili &quot;Univerzitet&quot;
apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Stock Izvještaji
DocType: Warehouse,Warehouse Detail,Detalji o skladištu
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.,Termin Završni datum ne može biti kasnije od kraja godine Datum akademske godine za koji je vezana pojam (akademska godina {}). Molimo ispravite datume i pokušajte ponovo.
apps/erpnext/erpnext/stock/doctype/item/item.py +284,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Da li je osnovno sredstvo&quot; ne može biti označeno, kao rekord imovine postoji u odnosu na stavku"
DocType: Delivery Trip,Departure Time,Vrijeme odlaska
DocType: Vehicle Service,Brake Oil,Brake ulje
DocType: Tax Rule,Tax Type,Vrste poreza
,Completed Work Orders,Završene radne naloge
DocType: Support Settings,Forum Posts,Forum Posts
apps/erpnext/erpnext/controllers/taxes_and_totals.py +598,Taxable Amount,oporezivi iznos
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +161,You are not authorized to add or update entries before {0},Niste ovlašteni za dodati ili ažurirati unose prije {0}
DocType: Leave Policy,Leave Policy Details,Ostavite detalje o politici
DocType: BOM,Item Image (if not slideshow),Slika proizvoda (ako nije slide prikaz)
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Satnica / 60) * Puna radno vrijeme
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1136,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Red # {0}: Referentni tip dokumenta mora biti jedan od potraživanja troškova ili unosa dnevnika
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1050,Select BOM,Izaberite 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,Troškovi isporučenih Predmeti
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +39,The holiday on {0} is not between From Date and To Date,Na odmor na {0} nije između Od datuma i Do datuma
DocType: Inpatient Record,Admission Scheduled,Prijem zakazan
DocType: Student Log,Student Log,student Prijavite
apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Šabloni pozicija dobavljača.
DocType: Lead,Interested,Zainteresovan
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Opening,Otvaranje
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +36,From {0} to {1},Od {0} do {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234,Program: ,Program:
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Neuspešno podešavanje poreza
DocType: Item,Copy From Item Group,Primjerak iz točke Group
DocType: Journal Entry,Opening Entry,Otvaranje unos
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Račun plaćaju samo
DocType: Loan,Repay Over Number of Periods,Otplatiti Preko broj perioda
DocType: Stock Entry,Additional Costs,Dodatni troškovi
apps/erpnext/erpnext/accounts/doctype/account/account.py +145,Account with existing transaction can not be converted to group.,Konto sa postojećim transakcijama se ne može pretvoriti u grupu konta .
DocType: Lead,Product Enquiry,Na upit
DocType: Education Settings,Validate Batch for Students in Student Group,Potvrditi Batch za studente u Studentskom Group
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +38,No leave record found for employee {0} for {1},Nema odmora Snimanje pronađena za zaposlenog {0} za {1}
DocType: Company,Unrealized Exchange Gain/Loss Account,Nerealizirani račun za dobitak / gubitak
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Unesite tvrtka prva
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +626,Please select Company first,Molimo najprije odaberite Company
DocType: Employee Education,Under Graduate,Pod diplomski
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +291,Please set default template for Leave Status Notification in HR Settings.,Molimo podesite podrazumevani obrazac za obaveštenje o statusu ostavljanja u HR postavkama.
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Target Na
DocType: BOM,Total Cost,Ukupan trošak
DocType: Soil Analysis,Ca/K,Ca / K
DocType: Salary Slip,Employee Loan,zaposlenik kredita
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-. MM.-
DocType: Fee Schedule,Send Payment Request Email,Pošaljite zahtev za plaćanje
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +277,Item {0} does not exist in the system or has expired,Artikal {0} ne postoji u sustavu ili je istekao
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,Ostavite prazno ako je Dobavljač blokiran na neodređeno vreme
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Nekretnine
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Izjava o računu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Lijekovi
DocType: Purchase Invoice Item,Is Fixed Asset,Fiksni Asset
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +351,"Available qty is {0}, you need {1}","Dostupno Količina je {0}, potrebno je {1}"
DocType: Expense Claim Detail,Claim Amount,Iznos štete
DocType: Patient,HLC-PAT-.YYYY.-,HLC-PAT-YYYY.-
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +644,Work Order has been {0},Radni nalog je bio {0}
DocType: Budget,Applicable on Purchase Order,Primenljivo na nalogu za kupovinu
DocType: Item,STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Duplikat grupe potrošača naći u tabeli Cutomer grupa
DocType: Location,Location Name,Ime lokacije
DocType: Naming Series,Prefix,Prefiks
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html +7,Event Location,Lokacija događaja
DocType: Asset Settings,Asset Settings,Postavke sredstva
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +71,Consumable,Potrošni
DocType: Student,B-,B-
DocType: Assessment Result,Grade,razred
DocType: Restaurant Table,No of Seats,Broj sedišta
DocType: Sales Invoice Item,Delivered By Supplier,Isporučuje dobavljač
DocType: Asset Maintenance Task,Asset Maintenance Task,Zadatak održavanja sredstava
DocType: SMS Center,All Contact,Svi kontakti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +213,Annual Salary,Godišnja zarada
DocType: Daily Work Summary,Daily Work Summary,Svakodnevni rad Pregled
DocType: Period Closing Voucher,Closing Fiscal Year,Zatvaranje Fiskalna godina
apps/erpnext/erpnext/accounts/party.py +425,{0} {1} is frozen,{0} {1} je smrznuto
apps/erpnext/erpnext/setup/doctype/company/company.py +152,Please select Existing Company for creating Chart of Accounts,Molimo odaberite postojećeg društva za stvaranje Kontni plan
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +84,Stock Expenses,Stock Troškovi
apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Odaberite Target Skladište
apps/erpnext/erpnext/hr/doctype/employee/employee.js +87,Please enter Preferred Contact Email,Unesite Preferred Kontakt mail
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Journal Entry Account,Credit in Company Currency,Credit Company valuta
DocType: Lab Test UOM,Lab Test UOM,Lab Test UOM
DocType: Delivery Note,Installation Status,Status instalacije
DocType: BOM,Quality Inspection Template,Šablon za proveru kvaliteta
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +136,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Da li želite da ažurirate prisustvo? <br> Prisutni: {0} \ <br> Odsutni: {1}
apps/erpnext/erpnext/controllers/buying_controller.py +421,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Količina prihvaćeno + odbijeno mora biti jednaka zaprimljenoj količini proizvoda {0}
DocType: Item,Supply Raw Materials for Purchase,Supply sirovine za kupovinu
DocType: Agriculture Analysis Criteria,Fertilizer,Đubrivo
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +427,"Cannot ensure delivery by Serial No as \
				Item {0} is added with and without Ensure Delivery by \
				Serial No.",Ne može se osigurati isporuka pomoću serijskog broja dok se \ Item {0} dodaje sa i bez Osiguranje isporuke od \ Serijski broj
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +203,At least one mode of payment is required for POS invoice.,Najmanje jedan način plaćanja je potreban za POS računa.
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,Stavka fakture za transakciju iz banke
DocType: Products Settings,Show Products as a List,Prikaži proizvode kao listu
DocType: Salary Detail,Tax on flexible benefit,Porez na fleksibilnu korist
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.py +43,Item {0} is not active or end of life has been reached,Stavka {0} nije aktivan ili kraj života je postignut
DocType: Student Admission Program,Minimum Age,Minimalna dob
apps/erpnext/erpnext/utilities/user_progress.py +190,Example: Basic Mathematics,Primjer: Osnovni Matematika
DocType: Customer,Primary Address,Primarna adresa
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +39,Diff Qty,Diff Količina
DocType: Production Plan,Material Request Detail,Zahtev za materijal za materijal
DocType: Selling Settings,Default Quotation Validity Days,Uobičajeni dani valute kvotiranja
apps/erpnext/erpnext/controllers/accounts_controller.py +870,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","To uključuje porez u redu {0} u stopu točke , porezi u redovima {1} također moraju biti uključeni"
DocType: SMS Center,SMS Center,SMS centar
DocType: Payroll Entry,Validate Attendance,Potvrdite prisustvo
DocType: Sales Invoice,Change Amount,Promjena Iznos
DocType: Party Tax Withholding Config,Certificate Received,Primljeno sertifikat
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Postavite vrednost fakture za B2C. B2CL i B2CS izračunati na osnovu ove fakture vrednosti.
DocType: BOM Update Tool,New BOM,Novi BOM
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +243,Prescribed Procedures,Propisane procedure
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Prikaži samo POS
DocType: Supplier Group,Supplier Group Name,Ime grupe dobavljača
DocType: Driver,Driving License Categories,Vozačke dozvole Kategorije
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +123,Please enter Delivery Date,Molimo unesite datum isporuke
DocType: Depreciation Schedule,Make Depreciation Entry,Make Amortizacija Entry
DocType: Closed Document,Closed Document,Zatvoreni dokument
DocType: HR Settings,Leave Settings,Ostavite podešavanja
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js +76,Number of positions cannot be less then current count of employees,Broj pozicija ne može biti manje od trenutnog broja zaposlenih
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Zahtjev Tip
DocType: Purpose of Travel,Purpose of Travel,Svrha putovanja
DocType: Payroll Period,Payroll Periods,Periodi plaćanja
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +18,Make Employee,Make zaposlenih
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,radiodifuzija
apps/erpnext/erpnext/config/accounts.py +351,Setup mode of POS (Online / Offline),Način podešavanja POS (Online / Offline)
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Onemogućava kreiranje evidencija vremena protiv radnih naloga. Operacije neće biti praćene radnim nalogom
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +167,Execution,izvršenje
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Detalji o poslovanju obavlja.
DocType: Asset Maintenance Log,Maintenance Status,Održavanje statusa
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Detalji o članstvu
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: dobavljača se protiv plaćaju račun {2}
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Stavke i cijene
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Ukupan broj sati: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma trebao biti u fiskalnoj godini. Uz pretpostavku Od datuma = {0}
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-YYYY.-
DocType: Drug Prescription,Interval,Interval
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Preference,Prednost
DocType: Supplier,Individual,Pojedinac
DocType: Academic Term,Academics User,akademici korisnika
DocType: Cheque Print Template,Amount In Figure,Iznos Na slici
DocType: Loan Application,Loan Info,kredit Info
apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plan održavanja posjeta.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Period perioda ocenjivanja dobavljača
DocType: Support Settings,Search APIs,API pretraživanja
DocType: Share Transfer,Share Transfer,Share Transfer
,Expiring Memberships,Istekao članstva
DocType: POS Profile,Customer Groups,Customer grupe
apps/erpnext/erpnext/public/js/financial_statements.js +53,Financial Statements,Finansijski izvještaji
DocType: Guardian,Students,studenti
apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Pravila za primjenu cijene i popust .
DocType: Daily Work Summary,Daily Work Summary Group,Dnevna radna grupa
DocType: Practitioner Schedule,Time Slots,Time Slots
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Cjenik mora biti primjenjiv za kupnju ili prodaju
DocType: Shift Assignment,Shift Request,Zahtjev za prebacivanje
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Datum Instalacija ne može biti prije datuma isporuke za točke {0}
DocType: Pricing Rule,Discount on Price List Rate (%),Popust na cijenu List stopa (%)
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Šablon predmeta
DocType: Job Offer,Select Terms and Conditions,Odaberite uvjeti
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +80,Out Value,out vrijednost
DocType: Bank Statement Settings Item,Bank Statement Settings Item,Stavka Postavke banke
DocType: Woocommerce Settings,Woocommerce Settings,Woocommerce postavke
DocType: Production Plan,Sales Orders,Sales Orders
apps/erpnext/erpnext/selling/doctype/customer/customer.py +203,Multiple Loyalty Program found for the Customer. Please select manually.,Višestruki program lojalnosti pronađen za klijenta. Molimo izaberite ručno.
DocType: Purchase Taxes and Charges,Valuation,Procjena
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +436,Set as Default,Postavi kao podrazumjevano
,Purchase Order Trends,Trendovi narudžbenica kupnje
apps/erpnext/erpnext/utilities/user_progress.py +78,Go to Customers,Idi na kupce
DocType: Hotel Room Reservation,Late Checkin,Late Checkin
apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Zahtjev za ponudu se može pristupiti klikom na sljedeći link
DocType: SG Creation Tool Course,SG Creation Tool Course,SG Stvaranje Alat za golf
DocType: Bank Statement Transaction Invoice Item,Payment Description,Opis plaćanja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +353,Insufficient Stock,nedovoljna Stock
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Onemogućite planiranje kapaciteta i Time Tracking
DocType: Email Digest,New Sales Orders,Nove narudžbenice
DocType: Bank Account,Bank Account,Žiro račun
DocType: Travel Itinerary,Check-out Date,Datum odlaska
DocType: Leave Type,Allow Negative Balance,Dopustite negativan saldo
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Ne možete obrisati tip projekta &#39;Spoljni&#39;
apps/erpnext/erpnext/public/js/utils.js +254,Select Alternate Item,Izaberite Alternativnu stavku
DocType: Employee,Create User,Kreiranje korisnika
DocType: Selling Settings,Default Territory,Zadani teritorij
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televizija
DocType: Work Order Operation,Updated via 'Time Log',Ažurirano putem 'Time Log'
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +13,Select the customer or supplier.,Izaberite kupca ili dobavljača.
apps/erpnext/erpnext/controllers/taxes_and_totals.py +444,Advance amount cannot be greater than {0} {1},iznos Advance ne može biti veći od {0} {1}
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +55,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Vremenski slot preskočen, slot {0} do {1} se preklapa sa postojećim slotom {2} do {3}"
DocType: Naming Series,Series List for this Transaction,Serija Popis za ovu transakciju
DocType: Company,Enable Perpetual Inventory,Omogućiti vječni zaliha
DocType: Bank Guarantee,Charges Incurred,Napunjene naknade
DocType: Company,Default Payroll Payable Account,Uobičajeno zarade plaćaju nalog
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Update-mail Group
DocType: Sales Invoice,Is Opening Entry,Je Otvaranje unos
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Ako nije potvrđena, stavka neće biti prikazana u fakturi za prodaju, ali se može koristiti u kreiranju grupnih testova."
DocType: Customer Group,Mention if non-standard receivable account applicable,Spomenite ako nestandardnih potraživanja računa važećim
DocType: Course Schedule,Instructor Name,instruktor ime
DocType: Company,Arrear Component,Arrear Component
DocType: Supplier Scorecard,Criteria Setup,Postavljanje kriterijuma
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,For Warehouse is required before Submit,Jer je potrebno Warehouse prije Podnijeti
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Primljen
DocType: Codification Table,Medical Code,Medicinski kod
apps/erpnext/erpnext/config/integrations.py +37,Connect Amazon with ERPNext,Povežite Amazon sa ERPNext
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Unesite tvrtke
DocType: Delivery Note Item,Against Sales Invoice Item,Protiv prodaje fakture Item
DocType: Agriculture Analysis Criteria,Linked Doctype,Linked Doctype
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Cash from Financing,Neto gotovine iz aktivnosti finansiranja
apps/erpnext/erpnext/accounts/page/pos/pos.js +2386,"LocalStorage is full , did not save","LocalStorage je puna, nije spasio"
DocType: Lead,Address & Contact,Adresa i kontakt
DocType: Leave Allocation,Add unused leaves from previous allocations,Dodaj neiskorišteni lišće iz prethodnog izdvajanja
DocType: Sales Partner,Partner website,website partner
DocType: Restaurant Order Entry,Add Item,Dodaj stavku
DocType: Party Tax Withholding Config,Party Tax Withholding Config,Konfiguracija poreza na strance
DocType: Lab Test,Custom Result,Prilagođeni rezultat
DocType: Delivery Stop,Contact Name,Kontakt ime
DocType: Course Assessment Criteria,Course Assessment Criteria,Kriteriji procjene naravno
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +31,Tax Id: ,Porezni ID:
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216,Student ID: ,Student ID:
DocType: POS Customer Group,POS Customer Group,POS kupaca Grupa
DocType: Healthcare Practitioner,Practitioner Schedules,Raspored lekara
DocType: Cheque Print Template,Line spacing for amount in words,Prored za iznos u riječima
DocType: Vehicle,Additional Details,Dodatni Detalji
apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Nema opisa dano
apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Zahtjev za kupnju.
DocType: POS Closing Voucher Details,Collected Amount,Prikupljeni iznos
DocType: Lab Test,Submitted Date,Datum podnošenja
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,To se temelji na vrijeme listovi stvorio protiv ovog projekta
,Open Work Orders,Otvorite radne naloge
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,Iznad Pansionske konsultantske stavke
DocType: Payment Term,Credit Months,Kreditni meseci
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +494,Net Pay cannot be less than 0,Neto Pay ne može biti manja od 0
DocType: Contract,Fulfilled,Ispunjeno
DocType: Inpatient Record,Discharge Scheduled,Pražnjenje je zakazano
apps/erpnext/erpnext/hr/doctype/employee/employee.py +131,Relieving Date must be greater than Date of Joining,Olakšavanja Datum mora biti veći od dana ulaska u
DocType: POS Closing Voucher,Cashier,Blagajna
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +221,Leaves per Year,Ostavlja per Godina
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +162,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Molimo provjerite 'Je li Advance ""protiv Account {1} ako je to unaprijed unos."
apps/erpnext/erpnext/stock/utils.py +243,Warehouse {0} does not belong to company {1},Skladište {0} ne pripada tvrtki {1}
DocType: Email Digest,Profit & Loss,Dobiti i gubitka
apps/erpnext/erpnext/utilities/user_progress.py +147,Litre,Litre
DocType: Task,Total Costing Amount (via Time Sheet),Ukupno Costing Iznos (preko Time Sheet)
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76,Please setup Students under Student Groups,Molimo da podesite studente pod studentskim grupama
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +181,Supplier &gt; Supplier Type,Dobavljač&gt; Tip dobavljača
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +31,Complete Job,Kompletan posao
DocType: Item Website Specification,Item Website Specification,Specifikacija web stranice artikla
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +546,Leave Blocked,Ostavite blokirani
apps/erpnext/erpnext/stock/doctype/item/item.py +798,Item {0} has reached its end of life on {1},Artikal {0} je dosegao svoj rok trajanja na {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +82,Bank Entries,banka unosi
DocType: Customer,Is Internal Customer,Je interni korisnik
DocType: Crop,Annual,godišnji
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +27,"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)","Ako se proveri automatsko uključivanje, klijenti će automatski biti povezani sa dotičnim programom lojalnosti (pri uštedi)"
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Pomirenje Item
DocType: Stock Entry,Sales Invoice No,Faktura prodaje br
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +145,Supply Type,Tip isporuke
DocType: Material Request Item,Min Order Qty,Min Red Kol
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Student Group Creation Tool Course
DocType: Lead,Do Not Contact,Ne kontaktirati
apps/erpnext/erpnext/utilities/user_progress.py +210,People who teach at your organisation,Ljudi koji predaju u vašoj organizaciji
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,Software Developer,Software Developer
DocType: Item,Minimum Order Qty,Minimalna količina za naručiti
DocType: Supplier,Supplier Type,Dobavljač Tip
DocType: Course Scheduling Tool,Course Start Date,Naravno Ozljede Datum
,Student Batch-Wise Attendance,Student Batch-Wise Posjećenost
DocType: POS Profile,Allow user to edit Rate,Dopustite korisniku da uređivanje objekta
DocType: Item,Publish in Hub,Objavite u Hub
DocType: Student Admission,Student Admission,student Ulaz
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +820,Item {0} is cancelled,Artikal {0} je otkazan
apps/erpnext/erpnext/assets/doctype/asset/asset.py +206,Depreciation Row {0}: Depreciation Start Date is entered as past date,Redosled amortizacije {0}: Početni datum amortizacije upisuje se kao prošli datum
DocType: Contract Template,Fulfilment Terms and Conditions,Uslovi ispunjavanja uslova
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1130,Material Request,Materijal zahtjev
DocType: Bank Reconciliation,Update Clearance Date,Ažurirajte provjeri datum
,GSTR-2,GSTR-2
DocType: Item,Purchase Details,Kupnja Detalji
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +490,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Stavka {0} nije pronađena u &#39;sirovine Isporučuje&#39; sto u narudžbenice {1}
DocType: Salary Slip,Total Principal Amount,Ukupni glavni iznos
DocType: Student Guardian,Relation,Odnos
DocType: Student Guardian,Mother,majka
DocType: Restaurant Reservation,Reservation End Time,Vreme završetka rezervacije
DocType: Crop,Biennial,Bijenale
,BOM Variance Report,Izveštaj BOM varijacije
apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Potvrđene narudžbe od kupaca.
DocType: Purchase Receipt Item,Rejected Quantity,Odbijen Količina
apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Zahtev za plaćanje {0} kreiran
DocType: Inpatient Record,Admitted Datetime,Prihvaćeno Datetime
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,Backflush sirovine iz radnog materijala u skladištu
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Open Orders,Otvori naloge
apps/erpnext/erpnext/healthcare/setup.py +187,Low Sensitivity,Niska osetljivost
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js +16,Order rescheduled for sync,Porudžbina je reprogramirana za sinhronizaciju
DocType: Notification Control,Notification Control,Obavijest kontrola
apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Potvrdite kad završite obuku
DocType: Lead,Suggestions,Prijedlozi
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Postavite Stavka Grupa-mudre proračune na ovom području. Također možete uključiti sezonalnost postavljanjem Distribution.
DocType: Payment Term,Payment Term Name,Naziv termina plaćanja
DocType: Healthcare Settings,Create documents for sample collection,Kreirajte dokumente za prikupljanje uzoraka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +308,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plaćanje protiv {0} {1} ne može biti veći od preostalog iznosa {2}
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py +9,All Healthcare Service Units,Sve jedinice zdravstvene službe
DocType: Bank Account,Address HTML,Adressa u HTML-u
DocType: Lead,Mobile No.,Mobitel broj
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html +35,Mode of Payments,Način plaćanja
DocType: Maintenance Schedule,Generate Schedule,Generiranje Raspored
DocType: Purchase Invoice Item,Expense Head,Rashodi voditelj
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +149,Please select Charge Type first,Odaberite Naknada za prvi
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.. ","Možete definisati sve zadatke koje je potrebno izvršiti za ovu žetvu ovdje. Dnevno polje se koristi da se pomene dan na koji se zadatak treba izvršiti, 1 je 1. dan itd."
DocType: Student Group Student,Student Group Student,Student Group Studentski
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +42,Latest,Najnovije
DocType: Asset Maintenance Task,2 Yearly,2 Yearly
DocType: Education Settings,Education Settings,Obrazovne postavke
DocType: Vehicle Service,Inspection,inspekcija
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,Bilans u osnovnoj valuti
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
DocType: Email Digest,New Quotations,Nove ponude
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +39,"Start date and end date is overlapping with the job card <a href=""#Form/Job Card/{0}"">{1}</a>","Datum početka i završetka se preklapa sa kartom posla <a href=""#Form/Job Card/{0}"">{1}</a>"
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +60,Attendance not submitted for {0} as {1} on leave.,Prisustvo nije dostavljeno {0} kao {1} na odsustvu.
DocType: Journal Entry,Payment Order,Nalog za plaćanje
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,E-poruke plate slip zaposlenog na osnovu preferirani mail izabrane u zaposlenih
DocType: Tax Rule,Shipping County,Dostava županije
DocType: Currency Exchange,For Selling,Za prodaju
apps/erpnext/erpnext/config/desktop.py +159,Learn,Učiti
DocType: Purchase Invoice Item,Enable Deferred Expense,Omogućite odloženi trošak
DocType: Asset,Next Depreciation Date,Sljedeća Amortizacija Datum
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Aktivnost Trošak po zaposlenom
DocType: Accounts Settings,Settings for Accounts,Postavke za račune
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +794,Supplier Invoice No exists in Purchase Invoice {0},Dobavljač Račun ne postoji u fakturi {0}
apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Menadzeri prodaje - Upravljanje.
DocType: Job Applicant,Cover Letter,Pismo
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Izvanredna Čekovi i depoziti očistiti
DocType: Item,Synced With Hub,Pohranjen Hub
DocType: Driver,Fleet Manager,Fleet Manager
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +566,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} ne može biti negativan za stavku {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +129,Wrong Password,Pogrešna lozinka
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-YYYY.-
DocType: Item,Variant Of,Varijanta
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',Završene Qty ne može biti veća od 'Količina za proizvodnju'
DocType: Period Closing Voucher,Closing Account Head,Zatvaranje računa šefa
DocType: Employee,External Work History,Vanjski History Work
apps/erpnext/erpnext/projects/doctype/task/task.py +111,Circular Reference Error,Kružna Reference Error
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206,Student Report Card,Studentski izveštaj kartica
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +207,From Pin Code,Od PIN-a
DocType: Appointment Type,Is Inpatient,Je stacionarno
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Guardian1 ime
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,Riječima (izvoz) će biti vidljivo nakon što spremite otpremnicu.
DocType: Cheque Print Template,Distance from left edge,Udaljenost od lijevog ruba
apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jedinice [{1}] (# obrazac / Stavka / {1}) naći u [{2}] (# obrazac / Skladište / {2})
DocType: Lead,Industry,Industrija
DocType: BOM Item,Rate & Amount,Stopa i količina
DocType: BOM,Transfer Material Against Job Card,Prenesite materijal protiv radne kartice
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Obavijesti putem e-pošte na stvaranje automatskog Materijal Zahtjeva
apps/erpnext/erpnext/healthcare/setup.py +191,Resistant,Otporno
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},Molimo podesite Hotel Room Rate na {}
DocType: Journal Entry,Multi Currency,Multi valuta
DocType: Bank Statement Transaction Invoice Item,Invoice Type,Tip fakture
DocType: Employee Benefit Claim,Expense Proof,Dokaz o troškovima
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +990,Delivery Note,Otpremnica
DocType: Patient Encounter,Encounter Impression,Encounter Impression
apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Postavljanje Poreza
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Cost of Sold Asset,Troškovi prodate imovine
DocType: Volunteer,Morning,Jutro
apps/erpnext/erpnext/accounts/utils.py +374,Payment Entry has been modified after you pulled it. Please pull it again.,Plaćanje Entry je izmijenjena nakon što ste ga izvukao. Molimo vas da se ponovo povucite.
DocType: Program Enrollment Tool,New Student Batch,Nova studentska serija
apps/erpnext/erpnext/stock/doctype/item/item.py +496,{0} entered twice in Item Tax,{0}pritisnite dva puta u sifri poreza
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +121,Summary for this week and pending activities,Pregled za ovaj tjedan i aktivnostima na čekanju
DocType: Student Applicant,Admitted,Prihvaćen
DocType: Workstation,Rent Cost,Rent cost
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +116,Amount After Depreciation,Iznos nakon Amortizacija
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Najave Kalendar događanja
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Varijanta atributi
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +114,Please select month and year,Molimo odaberite mjesec i godinu
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +53,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
					to cancel this document","Molimo obrišite Employee <a href=""#Form/Employee/{0}"">{0}</a> \ da biste otkazali ovaj dokument"
DocType: Employee,Company Email,Zvanični e-mail
DocType: GL Entry,Debit Amount in Account Currency,Debit Iznos u računu valuta
DocType: Supplier Scorecard,Scoring Standings,Tabelarni stavovi
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Da bi vrijednost
DocType: Certified Consultant,Certified Consultant,Certified Consultant
apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,transakcije protiv stranke ili za internu Transakcija / Cash
DocType: Shipping Rule,Valid for Countries,Vrijedi za zemlje
apps/erpnext/erpnext/stock/doctype/item/item.js +57,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,"Ovaj proizvod predložak i ne može se koristiti u transakcijama. Stavka atributi će se kopirati u više varijanti, osim 'Ne Copy ""je postavljena"
DocType: Grant Application,Grant Application,Grant aplikacija
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Ukupno Order Smatran
DocType: Certification Application,Not Certified,Nije sertifikovan
DocType: Asset Value Adjustment,New Asset Value,Nova vrijednost imovine
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Stopa po kojoj Kupac valuta se pretvaraju u kupca osnovne valute
DocType: Course Scheduling Tool,Course Scheduling Tool,Naravno rasporedu Tool
apps/erpnext/erpnext/controllers/accounts_controller.py +682,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: fakturi ne može se protiv postojeće imovine {1}
DocType: Crop Cycle,LInked Analysis,LInked Analysis
DocType: POS Closing Voucher,POS Closing Voucher,POS zatvoreni vaučer
DocType: Contract,Lapsed,Propušteno
DocType: Item Tax,Tax Rate,Porezna stopa
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +107,Application period cannot be across two allocation records,Period primene ne može biti preko dve evidencije alokacije
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +73,{0} already allocated for Employee {1} for period {2} to {3},{0} već izdvojeno za zaposlenog {1} {2} za razdoblje do {3}
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,Backflush sirovine od podizvođača na bazi
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +145,Purchase Invoice {0} is already submitted,Kupnja Račun {0} već je podnijela
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +90,Row # {0}: Batch No must be same as {1} {2},Row # {0}: serijski br mora biti isti kao {1} {2}
DocType: Material Request Plan Item,Material Request Plan Item,Zahtev za materijalni zahtev za materijal
DocType: Leave Type,Allow Encashment,Dozvoli Encashment
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +101,Convert to non-Group,Pretvoriti u non-Group
DocType: Project Update,Good/Steady,Dobro / stabilno
DocType: Bank Statement Transaction Invoice Item,Invoice Date,Datum fakture
DocType: GL Entry,Debit Amount,Debit Iznos
apps/erpnext/erpnext/accounts/party.py +277,There can only be 1 Account per Company in {0} {1},Tu može biti samo 1 račun po kompanije u {0} {1}
DocType: Support Search Source,Response Result Key Path,Response Result Key Path
DocType: Journal Entry,Inter Company Journal Entry,Inter Company Journal Entry
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +530,For quantity {0} should not be grater than work order quantity {1},Za količinu {0} ne bi trebalo biti veća od količine radnog naloga {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +524,Please see attachment,Pogledajte prilog
DocType: Purchase Order,% Received,% Primljeno
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Napravi studentske grupe
DocType: Volunteer,Weekends,Vikendi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +131,Credit Note Amount,Kredit Napomena Iznos
DocType: Setup Progress Action,Action Document,Akcioni dokument
DocType: Chapter Member,Website URL,Website URL
,Finished Goods,gotovih proizvoda
DocType: Delivery Note,Instructions,Instrukcije
DocType: Quality Inspection,Inspected By,Provjereno od strane
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-YYYY.-
DocType: Asset Maintenance Log,Maintenance Type,Održavanje Tip
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} nije upisanim na predmetu {2}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225,Student Name: ,Ime studenta:
DocType: POS Closing Voucher Details,Difference,Razlika
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serijski Ne {0} ne pripada isporuke Napomena {1}
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97,"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.","Izgleda da postoji problem sa konfiguracijom GoCardless servera. Ne brinite, u slučaju neuspeha, iznos će vam biti vraćen na vaš račun."
apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Dodaj Predmeti
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Parametar provjere kvalitete artikala
DocType: Leave Application,Leave Approver Name,Ostavite Approver Ime
DocType: Depreciation Schedule,Schedule Date,Raspored Datum
DocType: Amazon MWS Settings,FR,FR
DocType: Packed Item,Packed Item,Dostava Napomena Pakiranje artikla
DocType: Job Offer Term,Job Offer Term,Trajanje ponude za posao
apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Zadane postavke za transakciju kupnje.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Aktivnost troškova postoji za zaposlenog {0} protiv Aktivnost Tip - {1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +20,Mandatory field - Get Students From,Obavezna polja - Get Učenici iz
DocType: Program Enrollment,Enrolled courses,upisani kurseve
DocType: Currency Exchange,Currency Exchange,Mjenjačnica
DocType: Opening Invoice Creation Tool Item,Item Name,Naziv artikla
DocType: Authorization Rule,Approving User  (above authorized value),Odobravanje korisnika (iznad ovlašteni vrijednost)
DocType: Email Digest,Credit Balance,Credit Balance
DocType: Employee,Widowed,Udovički
DocType: Request for Quotation,Request for Quotation,Zahtjev za ponudu
DocType: Healthcare Settings,Require Lab Test Approval,Zahtevati odobrenje za testiranje laboratorija
DocType: Salary Slip Timesheet,Working Hours,Radno vrijeme
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Total Outstanding
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Promjena polaznu / tekući redni broj postojeće serije.
DocType: Dosage Strength,Strength,Snaga
apps/erpnext/erpnext/accounts/page/pos/pos.js +1548,Create a new Customer,Kreiranje novog potrošača
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +17,Expiring On,Ističe se
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.","Ako više Cijene pravila i dalje prevladavaju, korisnici su zamoljeni da postavite prioritet ručno riješiti sukob."
apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Napravi Narudžbenice
,Purchase Register,Kupnja Registracija
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116,Patient not found,Pacijent nije pronađen
DocType: Scheduling Tool,Rechedule,Rechedule
DocType: Landed Cost Item,Applicable Charges,Mjerodavno Optužbe
DocType: Workstation,Consumable Cost,potrošni cost
DocType: Purchase Receipt,Vehicle Date,Vozilo Datum
DocType: Student Log,Medical,liječnički
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +186,Reason for losing,Razlog za gubljenje
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1751,Please select Drug,Molimo izaberite Lijek
apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Lead Owner cannot be same as the Lead,Olovo Vlasnik ne može biti isti kao olovo
apps/erpnext/erpnext/accounts/utils.py +380,Allocated amount can not greater than unadjusted amount,Dodijeljeni iznos ne može veći od neprilagođena iznosa
DocType: Announcement,Receiver,prijemnik
DocType: Location,Area UOM,Područje UOM
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation je zatvoren sljedećih datuma po Holiday List: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +34,Opportunities,Prilike
DocType: Lab Test Template,Single,Singl
DocType: Compensatory Leave Request,Work From Date,Rad sa datuma
DocType: Salary Slip,Total Loan Repayment,Ukupno otplate kredita
DocType: Account,Cost of Goods Sold,Troškovi prodane robe
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +231,Please enter Cost Center,Unesite troška
DocType: Drug Prescription,Dosage,Doziranje
DocType: Journal Entry Account,Sales Order,Narudžbe kupca
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +67,Avg. Selling Rate,Prosj. Prodaja Rate
DocType: Assessment Plan,Examiner Name,Examiner Naziv
DocType: Lab Test Template,No Result,Bez rezultata
DocType: Purchase Invoice Item,Quantity and Rate,Količina i stopa
DocType: Delivery Note,% Installed,Instalirano%
apps/erpnext/erpnext/utilities/user_progress.py +230,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učionice / laboratorije, itd, gdje se mogu zakazati predavanja."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1301,Company currencies of both the companies should match for Inter Company Transactions.,Kompanijske valute obe kompanije treba da se podudaraju za transakcije Inter preduzeća.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +95,Please enter company name first,Unesite ime tvrtke prvi
DocType: Travel Itinerary,Non-Vegetarian,Ne-Vegetarijanac
DocType: Purchase Invoice,Supplier Name,Dobavljač Ime
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Pročitajte ERPNext Manual
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,Pokažite liste svih članova departmana u kalendaru
DocType: Purchase Invoice,01-Sales Return,01-Povratak prodaje
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +15,Temporarily on Hold,Privremeno na čekanju
DocType: Account,Is Group,Is Group
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +324,Credit Note {0} has been created automatically,Kreditna beleška {0} je kreirana automatski
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automatski se postavlja rednim brojevima na osnovu FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Check Dobavljač Faktura Broj Jedinstvenost
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Primarne adrese
DocType: Vehicle Service,Oil Change,Promjena ulja
DocType: Leave Encashment,Leave Balance,Ostavite ravnotežu
DocType: Asset Maintenance Log,Asset Maintenance Log,Dnevnik o održavanju imovine
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.','Za slucaj br' ne može biti manji od 'Od slucaja br'
DocType: Certification Application,Non Profit,Neprofitne
DocType: Production Plan,Not Started,Nije počela
DocType: Lead,Channel Partner,Partner iz prodajnog kanala
DocType: Account,Old Parent,Stari Roditelj
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +24,Mandatory field - Academic Year,Obavezna polja - akademska godina
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +221,{0} {1} is not associated with {2} {3},{0} {1} nije povezan sa {2} {3}
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Prilagodite uvodni tekst koji ide kao dio tog e-maila. Svaka transakcija ima zaseban uvodni tekst.
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +56,Row {0} : Operation is required against the raw material item {1},Red {0}: Operacija je neophodna prema elementu sirovine {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180,Please set default payable account for the company {0},Molimo postavite zadani plaća račun za kompaniju {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +604,Transaction not allowed against stopped Work Order {0},Transakcija nije dozvoljena zaustavljen Radni nalog {0}
DocType: Setup Progress Action,Min Doc Count,Min Doc Count
apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Global postavke za sve proizvodne procese.
DocType: Accounts Settings,Accounts Frozen Upto,Računi Frozen Upto
DocType: SMS Log,Sent On,Poslano na adresu
apps/erpnext/erpnext/stock/doctype/item/item.py +758,Attribute {0} selected multiple times in Attributes Table,Atribut {0} odabrani više puta u atributi tabeli
DocType: HR Settings,Employee record is created using selected field. ,Zapis o radniku je kreiran odabirom polja .
DocType: Sales Order,Not Applicable,Nije primjenjivo
DocType: Amazon MWS Settings,UK,UK
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,Otvaranje stavke fakture
DocType: Request for Quotation Item,Required Date,Potrebna Datum
DocType: Delivery Note,Billing Address,Adresa za naplatu
DocType: Bank Statement Settings,Statement Headers,Izjave zaglavlja
DocType: Travel Request,Costing,Koštanje
DocType: Tax Rule,Billing County,Billing županije
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Ako je označeno, iznos poreza će se smatrati već uključena u Print Rate / Ispis Iznos"
DocType: Request for Quotation,Message for Supplier,Poruka za dobavljača
DocType: Job Card,Work Order,Radni nalog
DocType: Sales Invoice,Total Qty,Ukupno Qty
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
DocType: Item,Show in Website (Variant),Pokaži u Web (Variant)
DocType: Employee,Health Concerns,Zdravlje Zabrinutost
DocType: Payroll Entry,Select Payroll Period,Odaberite perioda isplate
DocType: Purchase Invoice,Unpaid,Neplaćeno
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Rezervirano za prodaju
DocType: Packing Slip,From Package No.,Iz paketa broj
DocType: Item Attribute,To Range,U rasponu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Securities and Deposits,Vrijednosni papiri i depoziti
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +47,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Ne možete promijeniti način vrednovanja, jer postoje transakcije protiv nekih stvari koje nemaju svoj vlastiti način vrednovanja"
DocType: Student Report Generation Tool,Attended by Parents,Prisustvuju roditelji
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py +39,Employee {0} has already applied for {1} on {2} : ,Zaposleni {0} već je prijavio za {1} na {2}:
DocType: Inpatient Record,AB Positive,AB Pozitivan
DocType: Job Opening,Description of a Job Opening,Opis posla Otvaranje
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +118,Pending activities for today,Aktivnostima na čekanju za danas
DocType: Salary Structure,Salary Component for timesheet based payroll.,Plaća Komponenta za obračun plata na osnovu timesheet.
DocType: Driver,Applicable for external driver,Važeće za spoljni upravljački program
DocType: Sales Order Item,Used for Production Plan,Koristi se za plan proizvodnje
DocType: Loan,Total Payment,Ukupna uplata
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Cannot cancel transaction for Completed Work Order.,Ne mogu otkazati transakciju za Završeni radni nalog.
DocType: Manufacturing Settings,Time Between Operations (in mins),Vrijeme između operacije (u min)
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +823,PO already created for all sales order items,PO je već kreiran za sve stavke porudžbine
DocType: Healthcare Service Unit,Occupied,Zauzeti
DocType: Clinical Procedure,Consumables,Potrošni materijal
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +130,{0} {1} is cancelled so the action cannot be completed,{0} {1} je otkazan tako da akcija ne može završiti
DocType: Customer,Buyer of Goods and Services.,Kupac robe i usluga.
DocType: Journal Entry,Accounts Payable,Naplativa konta
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +55,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,"Iznos od {0} postavljen na ovaj zahtev za plaćanje razlikuje se od obračunatog iznosa svih planova plaćanja: {1}. Pre nego što pošaljete dokument, proverite da li je to tačno."
DocType: Patient,Allergies,Alergije
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +43,The selected BOMs are not for the same item,Izabrani sastavnica nisu za isti predmet
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +32,Change Item Code,Promenite stavku
DocType: Supplier Scorecard Standing,Notify Other,Obavesti drugu
DocType: Vital Signs,Blood Pressure (systolic),Krvni pritisak (sistolni)
DocType: Item Price,Valid Upto,Vrijedi Upto
DocType: Training Event,Workshop,radionica
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Upozoravajte narudžbenice
apps/erpnext/erpnext/utilities/user_progress.py +67,List a few of your customers. They could be organizations or individuals.,Navedite nekoliko svojih kupaca. Oni mogu biti tvrtke ili fizičke osobe.
DocType: Employee Tax Exemption Proof Submission,Rented From Date,Iznajmljen od datuma
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23,Enough Parts to Build,Dosta dijelova za izgradnju
DocType: POS Profile User,POS Profile User,POS korisnik profila
apps/erpnext/erpnext/assets/doctype/asset/asset.py +185,Row {0}: Depreciation Start Date is required,Red {0}: datum početka amortizacije je potreban
DocType: Purchase Invoice Item,Service Start Date,Datum početka usluge
DocType: Subscription Invoice,Subscription Invoice,Pretplata faktura
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Direct Income,Direktni prihodi
DocType: Patient Appointment,Date TIme,Date TIme
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +53,"Can not filter based on Account, if grouped by Account","Ne možete filtrirati na temelju računa , ako grupirani po računu"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Administrative Officer,Administrativni službenik
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Osnivanje preduzeća i porezi
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Molimo odaberite predmeta
DocType: Codification Table,Codification Table,Tabela kodifikacije
DocType: Timesheet Detail,Hrs,Hrs
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +410,Please select Company,Molimo odaberite Company
DocType: Stock Entry Detail,Difference Account,Konto razlike
DocType: Purchase Invoice,Supplier GSTIN,dobavljač GSTIN
apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,Ne možete zatvoriti zadatak kao zavisne zadatak {0} nije zatvoren.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,Unesite skladište za koje Materijal Zahtjev će biti podignuta
DocType: Work Order,Additional Operating Cost,Dodatni operativnih troškova
DocType: Lab Test Template,Lab Routine,Lab Routine
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,kozmetika
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Molimo izaberite Datum završetka za popunjeni dnevnik održavanja sredstava
apps/erpnext/erpnext/stock/doctype/item/item.py +569,"To merge, following properties must be same for both items","Spojiti , ova svojstva moraju biti isti za obje stavke"
DocType: Supplier,Block Supplier,Blok isporučilac
DocType: Shipping Rule,Net Weight,Neto težina
DocType: Job Opening,Planned number of Positions,Planirani broj pozicija
DocType: Employee,Emergency Phone,Hitna Telefon
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} ne postoji.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,kupiti
,Serial No Warranty Expiry,Serijski Nema jamstva isteka
DocType: Sales Invoice,Offline POS Name,Offline POS Ime
apps/erpnext/erpnext/utilities/user_progress.py +180,Student Application,Aplikacija za studente
DocType: Bank Statement Transaction Payment Item,Payment Reference,Reference za plaćanje
DocType: Supplier,Hold Type,Tip držanja
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Molimo vas da definirati razred za Threshold 0%
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,Stavka za plaćanje transakcije u banci
DocType: Sales Order,To Deliver,Dostaviti
DocType: Purchase Invoice Item,Item,Artikl
apps/erpnext/erpnext/healthcare/setup.py +188,High Sensitivity,Visoka osetljivost
apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Volonterski podaci o tipu.
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Šablon za mapiranje toka gotovine
DocType: Travel Request,Costing Details,Detalji o troškovima
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.js +64,Show Return Entries,Prikaži povratne unose
apps/erpnext/erpnext/accounts/page/pos/pos.js +2566,Serial no item cannot be a fraction,Serijski br stavka ne može biti frakcija
DocType: Journal Entry,Difference (Dr - Cr),Razlika ( dr. - Cr )
DocType: Bank Guarantee,Providing,Pružanje
DocType: Account,Profit and Loss,Račun dobiti i gubitka
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +99,"Not permitted, configure Lab Test Template as required","Nije dopušteno, konfigurirati Lab Test Template po potrebi"
DocType: Patient,Risk Factors,Faktori rizika
DocType: Patient,Occupational Hazards and Environmental Factors,Opasnosti po životnu sredinu i faktore zaštite životne sredine
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +317,Stock Entries already created for Work Order ,Upis zaliha već je kreiran za radni nalog
DocType: Vital Signs,Respiratory rate,Stopa respiratornih organa
apps/erpnext/erpnext/config/stock.py +337,Managing Subcontracting,Upravljanje Subcontracting
DocType: Vital Signs,Body Temperature,Temperatura tela
DocType: Project,Project will be accessible on the website to these users,Projekt će biti dostupna na web stranici ovih korisnika
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +292,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},Ne mogu da otkažem {0} {1} jer Serijski broj {2} ne pripada skladištu {3}
DocType: Detected Disease,Disease,Bolest
DocType: Company,Default Deferred Expense Account,Podrazumevani odloženi račun za troškove
apps/erpnext/erpnext/config/projects.py +29,Define Project type.,Definišite tip projekta.
DocType: Supplier Scorecard,Weighting Function,Funkcija ponderiranja
DocType: Healthcare Practitioner,OP Consulting Charge,OP Konsalting Charge
apps/erpnext/erpnext/utilities/user_progress.py +28,Setup your ,Postavite svoj
DocType: Student Report Generation Tool,Show Marks,Pokaži oznake
DocType: Support Settings,Get Latest Query,Najnoviji upit
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Stopa po kojoj Cjenik valute se pretvaraju u tvrtke bazne valute
apps/erpnext/erpnext/setup/doctype/company/company.py +74,Account {0} does not belong to company: {1},Konto {0} ne pripada preduzeću {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +56,Abbreviation already used for another company,Skraćenica već koristi za druge kompanije
DocType: Selling Settings,Default Customer Group,Zadana grupa korisnika
DocType: Employee,IFSC Code,IFSC kod
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Ako onemogućite, &#39;Ukupno&#39; Zaobljeni polje neće biti vidljiv u bilo kojoj transakciji"
DocType: BOM,Operating Cost,Operativni troškovi
DocType: Crop,Produced Items,Proizvedene stavke
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,Transakcija na fakture
DocType: Sales Order Item,Gross Profit,Bruto dobit
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +865,Unblock Invoice,Unblock Faktura
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Prirast ne može biti 0
DocType: Company,Delete Company Transactions,Izbrišite Company Transakcije
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +366,Reference No and Reference Date is mandatory for Bank transaction,Poziv na broj i referentni datum je obavezan za transakcije banke
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Dodaj / uredi poreze i troškove
DocType: Payment Entry Reference,Supplier Invoice No,Dobavljač Račun br
DocType: Territory,For reference,Za referencu
DocType: Healthcare Settings,Appointment Confirmation,Potvrda o imenovanju
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Cannot delete Serial No {0}, as it is used in stock transactions","Ne možete izbrisati serijski broj {0}, koji se koristi u prodaji transakcije"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +271,Closing (Cr),Zatvaranje (Cr)
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html +1,Hello,zdravo
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Move Stavka
DocType: Employee Incentive,Incentive Amount,Podsticajni iznos
DocType: Serial No,Warranty Period (Days),Jamstveni period (dani)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +76,Total Credit/ Debit Amount should be same as linked Journal Entry,Ukupan iznos kredita / zaduženja treba da bude isti kao vezani dnevnik
DocType: Installation Note Item,Installation Note Item,Napomena instalacije proizvoda
DocType: Production Plan Item,Pending Qty,U očekivanju Količina
DocType: Budget,Ignore,Ignorirati
apps/erpnext/erpnext/accounts/party.py +429,{0} {1} is not active,{0} {1} nije aktivan
DocType: Woocommerce Settings,Freight and Forwarding Account,Teretni i špediterski račun
apps/erpnext/erpnext/config/accounts.py +310,Setup cheque dimensions for printing,dimenzije ček setup za štampanje
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +33,Create Salary Slips,Napravite liste plata
DocType: Vital Signs,Bloated,Vatreno
DocType: Salary Slip,Salary Slip Timesheet,Plaća Slip Timesheet
apps/erpnext/erpnext/controllers/buying_controller.py +188,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavljač skladišta obvezan je za sub - ugovoreni kupiti primitka
DocType: Item Price,Valid From,Vrijedi od
DocType: Sales Invoice,Total Commission,Ukupno komisija
DocType: Tax Withholding Account,Tax Withholding Account,Porez na odbitak
DocType: Pricing Rule,Sales Partner,Prodajni partner
apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Sve ispostavne kartice.
DocType: Buying Settings,Purchase Receipt Required,Kupnja Potvrda Obvezno
DocType: Delivery Note,Rail,Rail
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +263,Target warehouse in row {0} must be same as Work Order,Ciljno skladište u redu {0} mora biti isto kao radni nalog
apps/erpnext/erpnext/stock/doctype/item/item.py +169,Valuation Rate is mandatory if Opening Stock entered,Vrednovanje Rate je obavezno ako ušla Otvaranje Stock
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143,No records found in the Invoice table,Nisu pronađeni u tablici fakturu
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +36,Please select Company and Party Type first,Molimo najprije odaberite Društva i Party Tip
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Već je postavljeno podrazumevano u profilu pos {0} za korisnika {1}, obično je onemogućeno podrazumevano"
apps/erpnext/erpnext/config/accounts.py +331,Financial / accounting year.,Financijska / obračunska godina .
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,akumulirani Vrijednosti
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +166,"Sorry, Serial Nos cannot be merged","Žao nam je , Serial Nos ne mogu spojiti"
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,Grupa potrošača će postaviti odabranu grupu dok sinhronizuje kupce iz Shopify-a
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Teritorija je potrebna u POS profilu
DocType: Supplier,Prevent RFQs,Sprečite RFQs
DocType: Hub User,Hub User,Hub User
apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Provjerite prodajnog naloga
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +537,Salary Slip submitted for period from {0} to {1},Plata za slanje poslata za period od {0} do {1}
DocType: Project Task,Project Task,Projektni zadatak
DocType: Loyalty Point Entry Redemption,Redeemed Points,Iskorišćene tačke
,Lead Id,Lead id
DocType: C-Form Invoice Detail,Grand Total,Ukupno za platiti
DocType: Assessment Plan,Course,Kurs
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +105,Section Code,Kodeks sekcije
DocType: Timesheet,Payslip,payslip
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +18,Half day date should be in between from date and to date,Datum pola dana treba da bude između datuma i datuma
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,stavka Košarica
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Fiskalna godina Start Date ne bi trebao biti veći od Fiskalna godina End Date
DocType: Issue,Resolution,Rezolucija
DocType: Employee,Personal Bio,Lični Bio
DocType: C-Form,IV,IV
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +15,Membership ID,ID članstva
apps/erpnext/erpnext/templates/pages/order.html +77,Delivered: {0},Isporučuje se: {0}
DocType: Bank Statement Transaction Entry,Payable Account,Račun se plaća
DocType: Payment Entry,Type of Payment,Vrsta plaćanja
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +18,Half Day Date is mandatory,Datum poluvremena je obavezan
DocType: Sales Order,Billing and Delivery Status,Obračun i Status isporuke
DocType: Job Applicant,Resume Attachment,Nastavi Prilog
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Ponovite Kupci
DocType: Leave Control Panel,Allocate,Dodijeli
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Kreiraj varijantu
DocType: Sales Invoice,Shipping Bill Date,Datum isporuke
DocType: Production Plan,Production Plan,Plan proizvodnje
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otvaranje alata za kreiranje fakture
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +906,Sales Return,Povrat robe
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +110,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Napomena: Ukupna izdvojena lišće {0} ne smije biti manja od već odobrenih lišće {1} za period
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,Postavite količinu u transakcijama na osnovu Serijski broj ulaza
,Total Stock Summary,Ukupno Stock Pregled
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +68,"You can only plan for upto {0} vacancies and budget {1} \
				for {2} as per staffing plan {3} for parent company {4}.",Možete planirati samo za {0} slobodna mesta i budžet {1} \ za {2} po planu osoblja {3} za matičnu kompaniju {4}.
DocType: Announcement,Posted By,Postavljeno od
DocType: Item,Delivered by Supplier (Drop Ship),Isporučuje Dobavljač (Drop Ship)
DocType: Healthcare Settings,Confirmation Message,Potvrda poruka
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Baza potencijalnih kupaca.
DocType: Authorization Rule,Customer or Item,Kupac ili stavka
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Šifarnik kupaca
DocType: Quotation,Quotation To,Ponuda za
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +305,Middle Income,Srednji Prihodi
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +243,Opening (Cr),P.S. (Pot)
apps/erpnext/erpnext/stock/doctype/item/item.py +930,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.,"Uobičajeno mjerna jedinica za artikl {0} ne može se mijenjati izravno, jer ste već napravili neke transakcije (e) sa drugim UOM. Morat ćete stvoriti nove stavke koristiti drugačiji Uobičajeno UOM."
apps/erpnext/erpnext/accounts/utils.py +378,Allocated amount can not be negative,Dodijeljeni iznos ne može biti negativan
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Molimo vas da postavite poduzeća
DocType: Share Balance,Share Balance,Podeli Balans
DocType: Amazon MWS Settings,AWS Access Key ID,AWS Access Key ID
DocType: Employee Tax Exemption Declaration,Monthly House Rent,Mjesečni najam kuće
DocType: Purchase Order Item,Billed Amt,Naplaćeni izn
DocType: Training Result Employee,Training Result Employee,Obuka Rezultat zaposlenih
DocType: Warehouse,A logical Warehouse against which stock entries are made.,A logično Skladište protiv kojih su napravljeni unosa zaliha.
apps/erpnext/erpnext/hr/doctype/loan/loan.js +134,Principal Amount,iznos glavnice
DocType: Loan Application,Total Payable Interest,Ukupno plaćaju interesa
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Outstanding: {0},Ukupno izvanredan: {0}
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Prodaja Račun Timesheet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,Reference No & Reference Date is required for {0},Reference Nema & Reference Datum je potrebno za {0}
DocType: Payroll Entry,Select Payment Account to make Bank Entry,Izaberite plaćanje računa da banke Entry
DocType: Hotel Settings,Default Invoice Naming Series,Podrazumevana faktura imenovanja serije
apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Kreiranje evidencije zaposlenih za upravljanje lišće, trošak potraživanja i platnom spisku"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +705,An error occurred during the update process,Došlo je do greške tokom procesa ažuriranja
DocType: Restaurant Reservation,Restaurant Reservation,Rezervacija restorana
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +166,Proposal Writing,Pisanje prijedlog
DocType: Payment Entry Deduction,Payment Entry Deduction,Plaćanje Entry Odbitak
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Zavijanje
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +43,Notify Customers via Email,Obaveštavajte kupce putem e-pošte
DocType: Item,Batch Number Series,Serija brojeva serija
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +54,Another Sales Person {0} exists with the same Employee id,Još jedna osoba Sales {0} postoji s istim ID zaposlenih
DocType: Employee Advance,Claimed Amount,Zahtevani iznos
DocType: Travel Itinerary,Departure Datetime,Odlazak Datetime
DocType: Customer,CUST-.YYYY.-,CUST-YYYY.-
DocType: Travel Request Costing,Travel Request Costing,Potraživanje putovanja
apps/erpnext/erpnext/config/education.py +180,Masters,Majstori
DocType: Employee Onboarding,Employee Onboarding Template,Template on Employing Employee
DocType: Assessment Plan,Maximum Assessment Score,Maksimalan rezultat procjene
apps/erpnext/erpnext/config/accounts.py +161,Update Bank Transaction Dates,Update Bank Transakcijski Termini
apps/erpnext/erpnext/config/projects.py +41,Time Tracking,Time Tracking
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICATE ZA TRANSPORTER
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +57,Row {0}# Paid Amount cannot be greater than requested advance amount,Red {0} # Plaćeni iznos ne može biti veći od tražene količine
DocType: Fiscal Year Company,Fiscal Year Company,Fiskalna godina Company
DocType: Packing Slip Item,DN Detail,DN detalj
DocType: Training Event,Conference,konferencija
DocType: Employee Grade,Default Salary Structure,Default Struktura plata
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py +23,Replies,Odgovori
DocType: Timesheet,Billed,Naplaćeno
DocType: Batch,Batch Description,Batch Opis
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Stvaranje grupa studenata
apps/erpnext/erpnext/accounts/utils.py +763,"Payment Gateway Account not created, please create one manually.","Payment Gateway računa kreiranu, molimo vas da napravite ručno."
DocType: Supplier Scorecard,Per Year,Godišnje
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Nije prihvatljiv za prijem u ovom programu prema DOB-u
DocType: Sales Invoice,Sales Taxes and Charges,Prodaja Porezi i naknade
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-YYYY.-
DocType: Vital Signs,Height (In Meter),Visina (u metrima)
DocType: Student,Sibling Details,Polubrat Detalji
DocType: Vehicle Service,Vehicle Service,Servis vozila
apps/erpnext/erpnext/config/setup.py +95,Automatically triggers the feedback request based on conditions.,Automatski aktivira zahtjev povratne informacije na osnovu uslova.
DocType: Employee,Reason for Resignation,Razlog za ostavku
DocType: Sales Invoice,Credit Note Issued,Kreditne Napomena Zadani
DocType: Project Task,Weight,težina
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Račun / Journal Entry Detalji
apps/erpnext/erpnext/accounts/utils.py +84,{0} '{1}' not in Fiscal Year {2},{0} ' {1} ' nije u fiskalnoj godini {2}
DocType: Buying Settings,Settings for Buying Module,Postavke za kupovinu modul
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +22,Asset {0} does not belong to company {1},Asset {0} ne pripada kompaniji {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Molimo prvo unesite Kupovina prijem
DocType: Buying Settings,Supplier Naming By,Dobavljač nazivanje
DocType: Activity Type,Default Costing Rate,Uobičajeno Costing Rate
DocType: Maintenance Schedule,Maintenance Schedule,Raspored održavanja
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +163,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Zatim Cjenovna Pravila filtriraju se temelji na Kupca, Kupac Group, Teritorij, dobavljač, proizvođač tip, Kampanja, prodajni partner i sl."
DocType: Employee Promotion,Employee Promotion Details,Detalji o promociji zaposlenih
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +83,Net Change in Inventory,Neto promjena u zalihama
DocType: Employee,Passport Number,Putovnica Broj
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Odnos sa Guardian2
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +112,Manager,menadžer
DocType: Payment Entry,Payment From / To,Plaćanje Od / Do
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +8,From Fiscal Year,Od fiskalne godine
apps/erpnext/erpnext/selling/doctype/customer/customer.py +185,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Novi kreditni limit je manje od trenutne preostali iznos za kupca. Kreditni limit mora biti atleast {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +447,Please set account in Warehouse {0},Molimo postavite nalog u skladištu {0}
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,' Temelji se na' i 'Grupisanje po ' ne mogu biti isti
DocType: Sales Person,Sales Person Targets,Prodaje osobi Mete
DocType: Work Order Operation,In minutes,U minuta
DocType: Issue,Resolution Date,Rezolucija Datum
DocType: Lab Test Template,Compound,Jedinjenje
DocType: Opportunity,Probability (%),Verovatnoća (%)
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py +11,Dispatch Notification,Obaveštenje o otpremi
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +56,Select Property,Izaberite svojstvo
DocType: Student Batch Name,Batch Name,Batch ime
DocType: Fee Validity,Max number of visit,Maksimalan broj poseta
,Hotel Room Occupancy,Hotelska soba u posjedu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Timesheet created:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1206,Please set default Cash or Bank account in Mode of Payment {0},Molimo postavite zadanu gotovinom ili banka računa u načinu plaćanja {0}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,upisati
DocType: GST Settings,GST Settings,PDV Postavke
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +81,Currency should be same as Price List Currency: {0},Valuta mora biti ista kao cenovnik Valuta: {0}
DocType: Selling Settings,Customer Naming By,Kupac Imenovanje By
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Će pokazati student kao sadašnjost u Studentskom Mjesečni Posjeta izvještaj
DocType: Depreciation Schedule,Depreciation Amount,Amortizacija Iznos
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +105,Convert to Group,Pretvori u Grupi
DocType: Activity Cost,Activity Type,Tip aktivnosti
DocType: Request for Quotation,For individual supplier,Za pojedinačne dobavljač
DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Company Valuta)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Delivered Amount,Isporučena Iznos
DocType: Loyalty Point Entry Redemption,Redemption Date,Datum otkupljenja
DocType: Quotation Item,Item Balance,stavka Balance
DocType: Sales Invoice,Packing List,Popis pakiranja
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Kupnja naloge koje je dao dobavljače.
DocType: Contract,Contract Template,Template Template
DocType: Clinical Procedure Item,Transfer Qty,Transfer Količina
DocType: Purchase Invoice Item,Asset Location,Lokacija imovine
DocType: Tax Rule,Shipping Zipcode,Isporuka Zipcode
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,objavljivanje
DocType: Accounts Settings,Report Settings,Postavke izveštaja
DocType: Activity Cost,Projects User,Projektni korisnik
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Consumed
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{0}: {1} not found in Invoice Details table,{0}: {1} nije pronađen u tabeli details na fakturi
DocType: Asset,Asset Owner Company,Vlasnička kompanija
DocType: Company,Round Off Cost Center,Zaokružimo troškova Center
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Posjeta za odrzavanje {0} mora biti otkazana prije otkazivanja ove ponude
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +14,Material Transfer,Materijal transfera
DocType: Cost Center,Cost Center Number,Broj troškovnog centra
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Ne mogu pronaći putanju za
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +236,Opening (Dr),P.S. (Dug)
DocType: Compensatory Leave Request,Work End Date,Datum završetka radova
DocType: Loan,Applicant,Podnosilac prijave
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +37,Posting timestamp must be after {0},Objavljivanje timestamp mora biti poslije {0}
apps/erpnext/erpnext/config/accounts.py +44,To make recurring documents,Da se ponavljaju dokumenti
,GST Itemised Purchase Register,PDV Specificirane Kupovina Registracija
DocType: Course Scheduling Tool,Reschedule,Ponovo raspored
DocType: Loan,Total Interest Payable,Ukupno kamata
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Sleteo Troškovi poreza i naknada
DocType: Work Order Operation,Actual Start Time,Stvarni Start Time
DocType: Purchase Invoice Item,Deferred Expense Account,Odloženi račun za troškove
DocType: BOM Operation,Operation Time,Operacija Time
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +466,Finish,završiti
DocType: Salary Structure Assignment,Base,baza
DocType: Timesheet,Total Billed Hours,Ukupno Fakturisana Hours
DocType: Travel Itinerary,Travel To,Putovati u
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1659,Write Off Amount,Napišite paušalni iznos
DocType: Leave Block List Allow,Allow User,Dopusti korisnika
DocType: Journal Entry,Bill No,Račun br
DocType: Company,Gain/Loss Account on Asset Disposal,Dobitak / gubitak računa na Asset Odlaganje
DocType: Vehicle Log,Service Details,usluga Detalji
DocType: Lab Test Template,Grouped,Grupisano
DocType: Selling Settings,Delivery Note Required,Potrebna je otpremnica
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +533,Submitting Salary Slips...,Podnošenje plata ...
DocType: Bank Guarantee,Bank Guarantee Number,Bankarska garancija Broj
DocType: Assessment Criteria,Assessment Criteria,Kriteriji procjene
DocType: BOM Item,Basic Rate (Company Currency),Osnovna stopa (valuta preduzeća)
apps/erpnext/erpnext/support/doctype/issue/issue.js +38,Split Issue,Split Issue
DocType: Student Attendance,Student Attendance,student Posjeta
DocType: Sales Invoice Timesheet,Time Sheet,Time Sheet
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush sirovine na osnovu
DocType: Sales Invoice,Port Code,Port Code
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1023,Reserve Warehouse,Rezervni skladište
DocType: Lead,Lead is an Organization,Olovo je organizacija
DocType: Guardian Interest,Interest,interes
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Pre Sales
DocType: Instructor Log,Other Details,Ostali detalji
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,Suplier
DocType: Lab Test,Test Template,Test Template
DocType: Restaurant Order Entry Item,Served,Servirano
apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Informacije o poglavlju.
DocType: Account,Accounts,Konta
DocType: Vehicle,Odometer Value (Last),Odometar vrijednost (Zadnje)
apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Šabloni za kriterijume rezultata dobavljača.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +351,Marketing,marketing
DocType: Sales Invoice,Redeem Loyalty Points,Iskoristite lojalnostne tačke
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +348,Payment Entry is already created,Plaćanje Ulaz je već stvorena
DocType: Request for Quotation,Get Suppliers,Uzmite dobavljača
DocType: Purchase Receipt Item Supplied,Current Stock,Trenutni Stock
apps/erpnext/erpnext/controllers/accounts_controller.py +665,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Asset {1} ne povezano sa Stavka {2}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +408,Preview Salary Slip,Preview Plaća Slip
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +64,Account {0} has been entered multiple times,Račun {0} je ušao više puta
DocType: Account,Expenses Included In Valuation,Troškovi uključeni u vrednovanje
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,Možete obnoviti samo ako vaše članstvo istekne u roku od 30 dana
DocType: Shopping Cart Settings,Show Stock Availability,Show Stock Availability
apps/erpnext/erpnext/assets/doctype/asset/asset.py +510,Set {0} in asset category {1} or company {2},Postavite {0} u kategoriji aktive {1} ili kompaniju {2}
DocType: Location,Longitude,Dužina
,Absent Student Report,Odsutan Student Report
DocType: Crop,Crop Spacing UOM,Crop Spacing UOM
DocType: Loyalty Program,Single Tier Program,Jednostavni program
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Samo izaberite ako imate postavke Map Flower Documents
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +189,From Address 1,Od adrese 1
DocType: Email Digest,Next email will be sent on:,Sljedeća e-mail će biti poslan na:
DocType: Supplier Scorecard,Per Week,Po tjednu
apps/erpnext/erpnext/stock/doctype/item/item.py +705,Item has variants.,Stavka ima varijante.
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Total Student
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Stavka {0} nije pronađena
DocType: Bin,Stock Value,Stock vrijednost
apps/erpnext/erpnext/accounts/doctype/account/account.py +202,Company {0} does not exist,Kompanija {0} ne postoji
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +43,{0} has fee validity till {1},{0} ima važeću tarifu do {1}
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54,Tree Type,Tip stabla
DocType: BOM Explosion Item,Qty Consumed Per Unit,Kol Potrošeno po jedinici
DocType: GST Account,IGST Account,IGST nalog
DocType: Serial No,Warranty Expiry Date,Datum isteka jamstva
DocType: Material Request Item,Quantity and Warehouse,Količina i skladišta
DocType: Sales Invoice,Commission Rate (%),Komisija stopa (%)
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Molimo odaberite program
DocType: Project,Estimated Cost,Procijenjeni troškovi
DocType: Request for Quotation,Link to material requests,Link za materijal zahtjeva
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Zračno-kosmički prostor
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
DocType: Journal Entry,Credit Card Entry,Credit Card Entry
apps/erpnext/erpnext/config/accounts.py +74,Company and Accounts,Company i računi
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +78,In Value,u vrijednost
DocType: Asset Settings,Depreciation Options,Opcije amortizacije
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Either location or employee must be required,Moraju biti potrebne lokacije ili zaposleni
apps/erpnext/erpnext/utilities/transaction_base.py +29,Invalid Posting Time,Neispravno vreme slanja poruka
DocType: Salary Component,Condition and Formula,Stanje i formula
DocType: Lead,Campaign Name,Naziv kampanje
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +61,There is no leave period in between {0} and {1},Nema perioda odlaska između {0} i {1}
DocType: Fee Validity,Healthcare Practitioner,Zdravstveni lekar
DocType: Hotel Room,Capacity,Kapacitet
DocType: Travel Request Costing,Expense Type,Tip rashoda
DocType: Selling Settings,Close Opportunity After Days,Zatvori Opportunity Nakon nekoliko dana
,Reserved,Rezervirano
DocType: Driver,License Details,Detalji o licenci
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +86,The field From Shareholder cannot be blank,Polje Od dioničara ne može biti prazno
DocType: Leave Allocation,Allocation,Alokacija
DocType: Purchase Order,Supply Raw Materials,Supply sirovine
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Dugotrajna imovina
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,{0} is not a stock Item,{0} ne postoji na zalihama.
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Molimo vas podelite svoje povratne informacije na trening klikom na &#39;Feedback Feedback&#39;, a zatim &#39;New&#39;"
DocType: Mode of Payment Account,Default Account,Podrazumjevani konto
apps/erpnext/erpnext/stock/doctype/item/item.py +288,Please select Sample Retention Warehouse in Stock Settings first,Prvo izaberite skladište za zadržavanje uzorka u postavkama zaliha
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +62,Please select the Multiple Tier Program type for more than one collection rules.,Molimo da izaberete tip višestrukog programa za više pravila kolekcije.
DocType: Payment Entry,Received Amount (Company Currency),Primljeni Iznos (Company Valuta)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,Lead mora biti postavljen ako je prilika iz njega izrađena
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136,Payment Cancelled. Please check your GoCardless Account for more details,Plaćanje je otkazano. Molimo provjerite svoj GoCardless račun za više detalja
DocType: Contract,N/A,N / A
DocType: Delivery Settings,Send with Attachment,Pošaljite sa Prilogom
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +30,Please select weekly off day,Odaberite tjednik off dan
DocType: Inpatient Record,O Negative,O Negativ
DocType: Work Order Operation,Planned End Time,Planirani End Time
,Sales Person Target Variance Item Group-Wise,Prodaja Osoba Target varijance artikla Group - Wise
apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Account with existing transaction cannot be converted to ledger,Konto sa postojećim transakcijama se ne može pretvoriti u glavnu knjigu
apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Detalji o tipu Memebership
DocType: Delivery Note,Customer's Purchase Order No,Kupca Narudžbenica br
DocType: Clinical Procedure,Consume Stock,Consume Stock
DocType: Budget,Budget Against,budžet protiv
apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,Auto materijala Zahtjevi Generirano
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Izgubljen
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +184,You can not enter current voucher in 'Against Journal Entry' column,Ne možete ući trenutni voucher u 'Protiv Journal Entry' koloni
DocType: Employee Benefit Application Detail,Max Benefit Amount,Max Benefit iznos
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Rezervirano za proizvodnju
DocType: Soil Texture,Sand,Pesak
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,energija
DocType: Opportunity,Opportunity From,Prilika od
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +990,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Red {0}: {1} Serijski brojevi potrebni za stavku {2}. Proveli ste {3}.
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Izaberite tabelu
DocType: BOM,Website Specifications,Web Specifikacije
DocType: Special Test Items,Particulars,Posebnosti
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +23,{0}: From {0} of type {1},{0}: Od {0} {1} tipa
apps/erpnext/erpnext/controllers/buying_controller.py +387,Row {0}: Conversion Factor is mandatory,Red {0}: pretvorbe Factor je obvezno
DocType: Student,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +353,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Više pravila Cijena postoji sa istim kriterijima, molimo vas da riješe sukob dodjelom prioriteta. Cijena pravila: {0}"
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Račun revalorizacije kursa
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +533,Cannot deactivate or cancel BOM as it is linked with other BOMs,Ne može se isključiti ili otkaže BOM kao što je povezano s drugim Boms
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js +106,Please select Company and Posting Date to getting entries,Molimo da odaberete Kompaniju i Datum objavljivanja da biste dobili unose
DocType: Asset,Maintenance,Održavanje
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Get from Patient Encounter,Izlazite iz susreta sa pacijentom
DocType: Subscriber,Subscriber,Pretplatnik
DocType: Item Attribute Value,Item Attribute Value,Stavka vrijednost atributa
apps/erpnext/erpnext/projects/doctype/project/project.py +472,Please Update your Project Status,Molimo Vas da ažurirate svoj status projekta
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +26,Currency Exchange must be applicable for Buying or for Selling.,Menjanje mjenjača mora biti primjenjivo za kupovinu ili prodaju.
DocType: Item,Maximum sample quantity that can be retained,Maksimalna količina uzorka koja se može zadržati
DocType: Project Update,How is the Project Progressing Right Now?,Kako se projekat napreduje odmah?
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +501,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Red {0} # Stavka {1} ne može se prenijeti više od {2} u odnosu na narudžbenicu {3}
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Prodajne kampanje.
DocType: Project Task,Make Timesheet,Make 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.","Standard poreza predložak koji se može primijeniti na sve poslove prodaje. Ovaj predložak može sadržavati popis poreskih glava i ostali rashodi / prihodi glave kao što su ""Shipping"", ""osiguranje"", ""Rukovanje"" itd 

 #### Napomena 

 Stopa poreza te definirati ovdje će biti standardna stopa poreza za sve ** Predmeti **. Ako postoje ** ** Predmeti koji imaju različite stope, oni moraju biti dodan u ** Stavka poreza na stolu ** u ** ** Stavka master.

 #### Opis Kolumne 

 1. Obračun Tip: 
 - To može biti na ** Neto Ukupno ** (to je zbroj osnovnog iznosa).
 - ** Na Prethodna Row Ukupan / Iznos ** (za kumulativni poreza ili naknada). Ako odaberete ovu opciju, porez će se primjenjivati kao postotak prethodnog reda (u tabeli poreza) iznos ili ukupno.
 - ** Stvarna ** (kao što je spomenuto).
 2. Račun Head: The račun knjigu pod kojima porez će biti kažnjen 
 3. Trošak Center: Ako porez / zadužen je prihod (kao što je shipping) ili rashod treba da se rezervirati protiv troška.
 4. Opis: Opis poreza (koje će se štampati u fakturama / navodnika).
 5. Rate: Stopa poreza.
 6. Iznos: Iznos PDV-a.
 7. Ukupno: Kumulativni ukupno do ove tačke.
 8. Unesite Row: Ako na osnovu ""Prethodna Row Ukupno"" možete odabrati broj reda koji se mogu uzeti kao osnova za ovaj proračun (default je prethodnog reda).
 9. Je li ovo pristojba uključena u Basic Rate ?: Ako označite ovu, to znači da ovaj porez neće biti prikazan ispod stola stavku, ali će biti uključeni u Basic Rate na glavnom stavku stola. To je korisno u kojoj želite dati cijena stana (uključujući sve poreze) cijene kupcima."
DocType: Employee,Bank A/C No.,Bankovni  A/C br.
DocType: Quality Inspection Reading,Reading 7,Čitanje 7
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,parcijalno uređenih
DocType: Lab Test,Lab Test,Lab Test
DocType: Student Report Generation Tool,Student Report Generation Tool,Alat za generisanje studenata
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,Vremenska raspored zdravstvene zaštite
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +163,Doc Name,Doc ime
apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Molimo vas da podesite sistem imenovanja instruktora u obrazovanju&gt; Obrazovne postavke
DocType: Expense Claim Detail,Expense Claim Type,Rashodi Vrsta polaganja
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Početne postavke za Košarica
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +27,Add Timeslots,Dodaj Timeslots
apps/erpnext/erpnext/stock/__init__.py +57,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},Molimo da postavite nalog u skladištu {0} ili podrazumevani račun inventara u kompaniji {1}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +143,Asset scrapped via Journal Entry {0},Asset odbačen preko Journal Entry {0}
DocType: Loan,Interest Income Account,Prihod od kamata računa
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +61,Max benefits should be greater than zero to dispense benefits,Maksimalne koristi bi trebalo da budu veće od nule da bi se izbacile koristi
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Poslato
DocType: Shift Assignment,Shift Assignment,Shift Assignment
DocType: Employee Transfer Property,Employee Transfer Property,Imovina Transfera zaposlenika
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py +36,From Time Should Be Less Than To Time,Od vremena bi trebalo biti manje od vremena
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Biotehnologija
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1117,"Item {0} (Serial No: {1}) cannot be consumed as is reserverd\
						 to fullfill Sales Order {2}.",Stavka {0} (serijski broj: {1}) ne može se potrošiti kao što je preserverd \ da biste popunili nalog za prodaju {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +116,Office Maintenance Expenses,Troškovi održavanja ureda
apps/erpnext/erpnext/utilities/user_progress.py +54,Go to ,Idi
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Ažurirajte cijenu od Shopify do ERPNext Cjenik
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Postavljanje e-pošte
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,Unesite predmeta prvi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +316,Needs Analysis,Analiza potreba
DocType: Asset Repair,Downtime,Zaustavljanje
DocType: Account,Liability,Odgovornost
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +227,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionisano Iznos ne može biti veći od potraživanja Iznos u nizu {0}.
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14,Academic Term: ,Akademski termin:
DocType: Salary Component,Do not include in total,Ne uključujte u potpunosti
DocType: Company,Default Cost of Goods Sold Account,Uobičajeno Nabavna vrednost prodate robe računa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1283,Sample quantity {0} cannot be more than received quantity {1},Količina uzorka {0} ne može biti veća od primljene količine {1}
apps/erpnext/erpnext/stock/get_item_details.py +523,Price List not selected,Popis Cijena ne bira
DocType: Employee,Family Background,Obitelj Pozadina
DocType: Request for Quotation Supplier,Send Email,Pošaljite e-mail
apps/erpnext/erpnext/stock/doctype/item/item.py +243,Warning: Invalid Attachment {0},Upozorenje: Invalid Prilog {0}
DocType: Item,Max Sample Quantity,Maksimalna količina uzorka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +810,No Permission,Bez dozvole
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrolna lista Ispunjavanja ugovora
DocType: Vital Signs,Heart Rate / Pulse,Srčana brzina / impuls
DocType: Company,Default Bank Account,Zadani bankovni račun
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +75,"To filter based on Party, select Party Type first","Da biste filtrirali na osnovu stranke, izaberite Party prvog tipa"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +46,'Update Stock' can not be checked because items are not delivered via {0},'Azuriranje zalihe' se ne može provjeriti jer artikli nisu dostavljeni putem {0}
DocType: Vehicle,Acquisition Date,akvizicija Datum
apps/erpnext/erpnext/utilities/user_progress.py +146,Nos,Nos
DocType: Item,Items with higher weightage will be shown higher,Predmeti sa višim weightage će biti prikazan veći
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py +12,Lab Tests and Vital Signs,Laboratorijski testovi i vitalni znaci
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Banka Pomirenje Detalj
apps/erpnext/erpnext/controllers/accounts_controller.py +669,Row #{0}: Asset {1} must be submitted,Row # {0}: Asset {1} moraju biti dostavljeni
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Niti jedan zaposlenik pronađena
DocType: Item,If subcontracted to a vendor,Ako podizvođača na dobavljača
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +113,Student Group is already updated.,Student Grupa je već ažurirana.
apps/erpnext/erpnext/config/projects.py +18,Project Update.,Ažuriranje projekta.
DocType: SMS Center,All Customer Contact,Svi kontakti kupaca
DocType: Location,Tree Details,Tree Detalji
DocType: Marketplace Settings,Registered,Registrovano
DocType: Training Event,Event Status,Event Status
DocType: Volunteer,Availability Timeslot,Availability Timeslot
,Support Analytics,Podrska za Analitiku
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +410,"If you have any questions, please get back to us.","Ako imate bilo kakvih pitanja, molimo Vas da se vratimo na nas."
DocType: Cash Flow Mapper,Cash Flow Mapper,Mapper za gotovinski tok
DocType: Item,Website Warehouse,Web stranica galerije
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimalni iznos fakture
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +112,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Cost Center {2} ne pripada kompaniji {3}
apps/erpnext/erpnext/utilities/user_progress.py +92,Upload your letter head (Keep it web friendly as 900px by 100px),Otpremite svoju pismo glavom (Držite ga na webu kao 900px po 100px)
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +89,{0} {1}: Account {2} cannot be a Group,{0} {1}: Račun {2} ne može biti Group
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +366,Timesheet {0} is already completed or cancelled,Timesheet {0} je već završen ili otkazan
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,No zadataka
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +81,Sales Invoice {0} created as paid,Prodajna faktura {0} stvorena je kao plaćena
DocType: Item Variant Settings,Copy Fields to Variant,Kopiraj polja na varijantu
DocType: Asset,Opening Accumulated Depreciation,Otvaranje Ispravka vrijednosti
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +50,Score must be less than or equal to 5,Ocjena mora biti manja od ili jednaka 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Program Upis Tool
apps/erpnext/erpnext/config/accounts.py +373,C-Form records,C - Form zapisi
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +74,The shares already exist,Akcije već postoje
apps/erpnext/erpnext/config/selling.py +322,Customer and Supplier,Kupaca i dobavljača
DocType: Email Digest,Email Digest Settings,E-pošta Postavke
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +412,Thank you for your business!,Hvala vam za vaše poslovanje!
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Podrska zahtjeva od strane korisnika
DocType: Employee Property History,Employee Property History,Istorija imovine zaposlenih
DocType: Setup Progress Action,Action Doctype,Action Doctype
DocType: HR Settings,Retirement Age,Retirement Godine
DocType: Bin,Moving Average Rate,Premještanje prosječna stopa
DocType: Production Plan,Select Items,Odaberite artikle
DocType: Share Transfer,To Shareholder,Za dioničara
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +408,{0} against Bill {1} dated {2},{0} protiv placanje {1}  od {2}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +213,From State,Od države
apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Institution,Setup Institution
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +73,Allocating leaves...,Raspodjela listova ...
DocType: Program Enrollment,Vehicle/Bus Number,Vozila / Autobus broj
apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Raspored za golf
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +570,"You have to Deduct Tax for Unsubmitted Tax Exemption Proof and Unclaimed \
					Employee Benefits in the last Salary Slip of Payroll Period",Morate oduzeti porez za neosvojen dokaz o oslobađanju od poreza i nepropisane koristi zaposlenima u poslednjem periodu platnog spiska
DocType: Request for Quotation Supplier,Quote Status,Quote Status
DocType: GoCardless Settings,Webhooks Secret,Webhooks Secret
DocType: Maintenance Visit,Completion Status,Završetak Status
DocType: Daily Work Summary Group,Select Users,Izaberite Korisnike
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Stavka hotela u sobi
DocType: Loyalty Program Collection,Tier Name,Tier Name
DocType: HR Settings,Enter retirement age in years,Unesite dob za odlazak u penziju u godinama
DocType: Crop,Target Warehouse,Ciljana galerija
DocType: Payroll Employee Detail,Payroll Employee Detail,Detalji o zaposlenima
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +135,Please select a warehouse,Molimo odaberite skladište
DocType: Cheque Print Template,Starting location from left edge,Početna lokacija od lijevog ruba
DocType: Item,Allow over delivery or receipt upto this percent,Dozvolite preko isporuke ili primitka upto ovu posto
DocType: Upload Attendance,Import Attendance,Uvoz posjećenost
apps/erpnext/erpnext/public/js/pos/pos.html +124,All Item Groups,Sve grupe artikala
DocType: Work Order,Item To Manufacture,Artikal za proizvodnju
apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} {2} status
DocType: Water Analysis,Collection Temperature ,Temperatura kolekcije
DocType: Employee,Provide Email Address registered in company,Osigurati mail registrovan u kompaniji Adresa
DocType: Shopping Cart Settings,Enable Checkout,Enable Checkout
apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Purchase Order na isplatu
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Projektovana kolicina
DocType: Sales Invoice,Payment Due Date,Plaćanje Due Date
DocType: Drug Prescription,Interval UOM,Interval UOM
DocType: Customer,"Reselect, if the chosen address is edited after save","Ponovo odaberite, ako je izabrana adresa uređena nakon čuvanja"
apps/erpnext/erpnext/stock/doctype/item/item.js +601,Item Variant {0} already exists with same attributes,Stavka Variant {0} već postoji s istim atributima
DocType: Item,Hub Publishing Details,Detalji izdavanja stanice
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +135,'Opening',&#39;Otvaranje&#39;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Open To Do
DocType: Issue,Via Customer Portal,Preko portala za kupce
DocType: Notification Control,Delivery Note Message,Otpremnica - poruka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +322,SGST Amount,SGST Iznos
DocType: Lab Test Template,Result Format,Format rezultata
DocType: Expense Claim,Expenses,troškovi
DocType: Item Variant Attribute,Item Variant Attribute,Stavka Variant Atributi
,Purchase Receipt Trends,Račun kupnje trendovi
DocType: Payroll Entry,Bimonthly,časopis koji izlazi svaka dva mjeseca
DocType: Vehicle Service,Brake Pad,Brake Pad
DocType: Fertilizer,Fertilizer Contents,Sadržaj đubriva
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +361,Research & Development,Istraživanje i razvoj
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Iznos za naplatu
DocType: Company,Registration Details,Registracija Brodu
DocType: Timesheet,Total Billed Amount,Ukupno Fakturisana iznos
DocType: Item Reorder,Re-Order Qty,Re-order Količina
DocType: Leave Block List Date,Leave Block List Date,Ostavite Date Popis Block
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +101,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Sirovi materijal ne može biti isti kao i glavna stavka
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,Ukupno Primjenjivo Optužbe na račun za prodaju Predmeti sto mora biti isti kao Ukupni porezi i naknada
DocType: Sales Team,Incentives,Poticaji
DocType: SMS Log,Requested Numbers,Traženi brojevi
DocType: Volunteer,Evening,Veče
DocType: Customer,Bypass credit limit check at Sales Order,Provjerite kreditni limit za obilaznicu na nalogu za prodaju
DocType: Vital Signs,Normal,Normalno
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +106,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Omogućavanje &#39;Koristi se za korpa &quot;, kao košarica je omogućen i treba da postoji barem jedan poreza pravilo za Košarica"
DocType: Sales Invoice Item,Stock Details,Stock Detalji
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Vrijednost Projekta
apps/erpnext/erpnext/config/selling.py +332,Point-of-Sale,Point-of-prodaju
DocType: Fee Schedule,Fee Creation Status,Status stvaranja naknade
DocType: Vehicle Log,Odometer Reading,odometar Reading
apps/erpnext/erpnext/accounts/doctype/account/account.py +123,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Stanje računa već u kredit, što se ne smije postaviti 'ravnoteža se mora' kao 'zaduženje """
DocType: Account,Balance must be,Bilans mora biti
DocType: Notification Control,Expense Claim Rejected Message,Rashodi Zahtjev odbijen poruku
,Available Qty,Dostupno Količina
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,Podrazumevano skladište za kreiranje naloga za prodaju i dostave
DocType: Purchase Taxes and Charges,On Previous Row Total,Na prethodni redak Ukupno
DocType: Purchase Invoice Item,Rejected Qty,odbijena Količina
DocType: Setup Progress Action,Action Field,Akciono polje
DocType: Healthcare Settings,Manage Customer,Upravljajte kupcima
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,Uvek sinhronizujte svoje proizvode sa Amazon MWS pre sinhronizacije detalja o narudžbini
DocType: Delivery Trip,Delivery Stops,Dostava je prestala
DocType: Salary Slip,Working Days,Radnih dana
apps/erpnext/erpnext/accounts/deferred_revenue.py +33,Cannot change Service Stop Date for item in row {0},Nije moguće promeniti datum zaustavljanja usluge za stavku u redu {0}
DocType: Serial No,Incoming Rate,Dolazni Stopa
DocType: Packing Slip,Gross Weight,Bruto težina
DocType: Leave Type,Encashment Threshold Days,Dani praga osiguravanja
,Final Assessment Grades,Završne ocene
apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,Ime vaše tvrtke za koje ste postavljanje ovog sustava .
DocType: HR Settings,Include holidays in Total no. of Working Days,Uključi odmor u ukupnom. radnih dana
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +107,Setup your Institute in ERPNext,Postavite svoj institut u ERPNext
DocType: Agriculture Analysis Criteria,Plant Analysis,Analiza biljaka
DocType: Job Applicant,Hold,Zadrži
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +101,Alternate Item,Alternativna jedinica
DocType: Project Update,Progress Details,Detalji o napretku
DocType: Shopify Log,Request Data,Zahtevajte podatke
DocType: Employee,Date of Joining,Datum pristupa
DocType: Naming Series,Update Series,Update serija
DocType: Supplier Quotation,Is Subcontracted,Je podugovarati
DocType: Restaurant Table,Minimum Seating,Minimalno sedenje
DocType: Item Attribute,Item Attribute Values,Stavka Atributi vrijednosti
DocType: Examination Result,Examination Result,ispitivanje Rezultat
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +921,Purchase Receipt,Račun kupnje
,Received Items To Be Billed,Primljeni Proizvodi se naplaćuje
apps/erpnext/erpnext/config/accounts.py +341,Currency exchange rate master.,Majstor valute .
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +210,Reference Doctype must be one of {0},Referentni Doctype mora biti jedan od {0}
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,Filter Total Zero Qty
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},U nemogućnosti da pronađe termin u narednih {0} dana za operaciju {1}
DocType: Work Order,Plan material for sub-assemblies,Plan materijal za podsklopove
apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Prodaja Partneri i teritorija
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +622,BOM {0} must be active,BOM {0} mora biti aktivna
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +427,No Items available for transfer,Nema stavki za prenos
DocType: Employee Boarding Activity,Activity Name,Naziv aktivnosti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +860,Change Release Date,Promeni datum izdanja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +214,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Završena količina proizvoda <b>{0}</b> i Za količinu <b>{1}</b> ne mogu biti različite
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +250,Closing (Opening + Total),Zatvaranje (otvaranje + ukupno)
DocType: Delivery Settings,Dispatch Notification Attachment,Prilog za obavještenje o otpremi
DocType: Payroll Entry,Number Of Employees,Broj zaposlenih
DocType: Journal Entry,Depreciation Entry,Amortizacija Entry
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +31,Please select the document type first,Molimo odaberite vrstu dokumenta prvi
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Odustani Posjeta materijala {0} prije otkazivanja ovog održavanja pohod
DocType: Pricing Rule,Rate or Discount,Stopa ili popust
DocType: Vital Signs,One Sided,Jednostrani
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,Serial No {0} does not belong to Item {1},Serijski Ne {0} ne pripada točki {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Potrebna Kol
DocType: Marketplace Settings,Custom Data,Korisnički podaci
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126,Warehouses with existing transaction can not be converted to ledger.,Skladišta sa postojećim transakcija se ne može pretvoriti u knjizi.
apps/erpnext/erpnext/controllers/buying_controller.py +570,Serial no is mandatory for the item {0},Serijski broj je obavezan za stavku {0}
DocType: Bank Reconciliation,Total Amount,Ukupan iznos
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +24,From Date and To Date lie in different Fiscal Year,Od datuma i do datuma leži u različitim fiskalnim godinama
apps/erpnext/erpnext/healthcare/utils.py +160,The Patient {0} do not have customer refrence to invoice,Pacijent {0} nema refrence kupca za fakturu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Internet izdavaštvo
DocType: Prescription Duration,Number,Broj
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Kreiranje {0} fakture
DocType: Medical Code,Medical Code Standard,Medical Code Standard
DocType: Soil Texture,Clay Composition (%),Glina sastav (%)
DocType: Item Group,Item Group Defaults,Podrazumevana postavka grupe
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +102,Please save before assigning task.,Molimo vas da sačuvate pre nego što dodate zadatak.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +82,Balance Value,Vrijednost bilance
DocType: Lab Test,Lab Technician,Laboratorijski tehničar
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +40,Sales Price List,Sales Cjenovnik
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.","Ako se proveri, biće kreiran korisnik, mapiran na Pacijent. Pacijentove fakture će biti stvorene protiv ovog Korisnika. Takođe možete izabrati postojećeg kupca prilikom stvaranja Pacijenta."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +63,Customer isn't enrolled in any Loyalty Program,Korisnik nije upisan u bilo koji program lojalnosti
DocType: Bank Reconciliation,Account Currency,Valuta račun
DocType: Lab Test,Sample ID,Primer uzorka
apps/erpnext/erpnext/accounts/general_ledger.py +178,Please mention Round Off Account in Company,Navedite zaokružimo računa u Company
DocType: Purchase Receipt,Range,Domet
DocType: Supplier,Default Payable Accounts,Uobičajeno Računi dobavljača
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +52,Employee {0} is not active or does not exist,Radnik {0} nije aktivan ili ne postoji
DocType: Fee Structure,Components,komponente
DocType: Support Search Source,Search Term Param Name,Termin za pretragu Param Ime
DocType: Item Barcode,Item Barcode,Barkod artikla
DocType: Woocommerce Settings,Endpoints,Krajnje tačke
apps/erpnext/erpnext/stock/doctype/item/item.py +700,Item Variants {0} updated,Stavka Varijante {0} ažurirani
DocType: Quality Inspection Reading,Reading 6,Čitanje 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +994,Cannot {0} {1} {2} without any negative outstanding invoice,Ne mogu {0} {1} {2} bez ikakvih negativnih izuzetan fakture
DocType: Share Transfer,From Folio No,Od Folio No
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Narudzbine avans
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +231,Row {0}: Credit entry can not be linked with a {1},Row {0}: Kredit stavka ne može se povezati sa {1}
apps/erpnext/erpnext/config/accounts.py +284,Define budget for a financial year.,Definirajte budžet za finansijsku godinu.
DocType: Shopify Tax Account,ERPNext Account,ERPNext nalog
apps/erpnext/erpnext/controllers/accounts_controller.py +57,{0} is blocked so this transaction cannot proceed,"{0} je blokiran, tako da se ova transakcija ne može nastaviti"
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Akcija ako je akumulirani mesečni budžet prešao na MR
DocType: Employee,Permanent Address Is,Stalna adresa je
DocType: Work Order Operation,Operation completed for how many finished goods?,Operacija završena za koliko gotovih proizvoda?
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +128,Healthcare Practitioner {0} not available on {1},Zdravstveni radnik {0} nije dostupan na {1}
DocType: Payment Terms Template,Payment Terms Template,Šablon izraza plaćanja
apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,The Brand
DocType: Employee Tax Exemption Proof Submission,Rented To Date,Iznajmljeno do datuma
DocType: Manufacturing Settings,Allow Multiple Material Consumption,Dozvolite višestruku potrošnju materijala
DocType: Employee,Exit Interview Details,Izlaz Intervju Detalji
DocType: Item,Is Purchase Item,Je dobavljivi proizvod
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Narudzbine
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Dozvoli višestruku potrošnju materijala protiv radnog naloga
DocType: GL Entry,Voucher Detail No,Bon Detalj Ne
apps/erpnext/erpnext/accounts/page/pos/pos.js +796,New Sales Invoice,Prodaja novih Račun
DocType: Stock Entry,Total Outgoing Value,Ukupna vrijednost Odlazni
DocType: Healthcare Practitioner,Appointments,Imenovanja
apps/erpnext/erpnext/public/js/account_tree_grid.js +223,Opening Date and Closing Date should be within same Fiscal Year,Datum otvaranja i zatvaranja datum bi trebao biti u istoj fiskalnoj godini
DocType: Lead,Request for Information,Zahtjev za informacije
,LeaderBoard,leaderboard
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Rate With Margin (Valuta kompanije)
apps/erpnext/erpnext/accounts/page/pos/pos.js +809,Sync Offline Invoices,Sync Offline Fakture
DocType: Payment Request,Paid,Plaćen
DocType: Program Fee,Program Fee,naknada za 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.","Zamenite određenu tehničku tehničku pomoć u svim ostalim BOM-u gde se koristi. On će zamijeniti stari BOM link, ažurirati troškove i regenerirati tabelu &quot;BOM Explosion Item&quot; po novom BOM-u. Takođe ažurira najnoviju cenu u svim BOM."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +468,The following Work Orders were created:,Stvoreni su sledeći Radni nalogi:
DocType: Salary Slip,Total in words,Ukupno je u riječima
DocType: Inpatient Record,Discharged,Ispušteni
DocType: Material Request Item,Lead Time Date,Datum i vrijeme Lead-a
,Employee Advance Summary,Advance Summary of Employee
DocType: Asset,Available-for-use Date,Datum dostupan za upotrebu
DocType: Guardian,Guardian Name,Guardian ime
DocType: Cheque Print Template,Has Print Format,Ima Print Format
DocType: Support Settings,Get Started Sections,Započnite sekcije
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
DocType: Loan,Sanctioned,sankcionisani
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +8,Total Contribution Amount: {0},Ukupan iznos doprinosa: {0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +179,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Navedite rednim brojem predmeta za {1}
DocType: Payroll Entry,Salary Slips Submitted,Iznosi plate poslati
DocType: Crop Cycle,Crop Cycle,Crop Cycle
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +678,"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.","Za &#39;proizvoda Bundle&#39; stavki, Magacin, serijski broj i serijski broj smatrat će se iz &#39;Pakiranje List&#39; stol. Ako Skladište i serijski broj su isti za sve pakovanje stavke za bilo &#39;Bundle proizvoda&#39; stavku, te vrijednosti mogu se unijeti u glavnom Stavka stola, vrijednosti će se kopirati u &#39;Pakiranje List&#39; stol."
DocType: Amazon MWS Settings,BR,BR
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +201,From Place,From Place
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +460,Net Pay cannnot be negative,Neto plate ne mogu biti negativne
DocType: Student Admission,Publish on website,Objaviti na web stranici
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +772,Supplier Invoice Date cannot be greater than Posting Date,Dobavljač Datum računa ne može biti veći od Datum knjiženja
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Subscription,Cancelation Date,Datum otkazivanja
DocType: Purchase Invoice Item,Purchase Order Item,Narudžbenica predmet
DocType: Agriculture Task,Agriculture Task,Poljoprivreda zadatak
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +139,Indirect Income,Neizravni dohodak
DocType: Student Attendance Tool,Student Attendance Tool,Student Posjeta Tool
DocType: Restaurant Menu,Price List (Auto created),Cenovnik (Automatski kreiran)
DocType: Cheque Print Template,Date Settings,Datum Postavke
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +76,Variance,Varijacija
DocType: Employee Promotion,Employee Promotion Detail,Detalji o napredovanju zaposlenih
,Company Name,Naziv preduzeća
DocType: SMS Center,Total Message(s),Ukupno poruka ( i)
DocType: Share Balance,Purchased,Kupljeno
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,Preimenuj vrijednost atributa u atributu predmeta.
DocType: Purchase Invoice,Additional Discount Percentage,Dodatni popust Procenat
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Pogledaj listu svih snimke Pomoć
DocType: Agriculture Analysis Criteria,Soil Texture,Tekstura tla
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Odaberite račun šefa banke gdje je ček bio pohranjen.
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Dopustite korisniku uređivanje cjenika u transakcijama
DocType: Pricing Rule,Max Qty,Max kol
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25,Print Report Card,Štampaj izveštaj karticu
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","Red {0}: Račun {1} je nevažeća, to može biti otkazan / ne postoji. \ Molimo unesite važeću fakture"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +164,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Plaćanje protiv Prodaja / narudžbenice treba uvijek biti označeni kao unaprijed
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Hemijski
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Uobičajeno Banka / Cash račun će se automatski ažurirati u Plaća Journal Entry kada je izabran ovaj režim.
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Total leaves allocated is mandatory for Leave Type {0},Ukupna izdvojena listića su obavezna za Tip Leave {0}
DocType: BOM,Raw Material Cost(Company Currency),Sirovina troškova (poduzeća Valuta)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +86,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: Rate ne može biti veća od stope koristi u {1} {2}
apps/erpnext/erpnext/utilities/user_progress.py +147,Meter,metar
DocType: Workstation,Electricity Cost,Troškovi struje
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py +15,Amount should be greater than zero.,Iznos mora biti veći od nule.
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23,Lab testing datetime cannot be before collection datetime,Labiranje testiranja datotime ne može biti pre snimanja datetime
DocType: Subscription Plan,Cost,Troškovi
DocType: HR Settings,Don't send Employee Birthday Reminders,Ne šaljite podsjetnik za rođendan zaposlenika
DocType: Expense Claim,Total Advance Amount,Ukupan avansni iznos
DocType: Delivery Stop,Estimated Arrival,Procijenjeni dolazak
apps/erpnext/erpnext/templates/pages/help.html +29,See All Articles,Vidi sve članke
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Walk In,Ulaz u
DocType: Item,Inspection Criteria,Inspekcijski Kriteriji
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Prenose
DocType: BOM Website Item,BOM Website Item,BOM Web Stavka
apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Unos glavu pismo i logo. (Možete ih kasnije uređivanje).
DocType: Timesheet Detail,Bill,račun
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +183,White,Bijel
DocType: SMS Center,All Lead (Open),Svi potencijalni kupci (aktualni)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +348,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Red {0}: Količina nije dostupan za {4} u skladištu {1} na postavljanje trenutku stupanja ({2} {3})
apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,Iz liste polja za potvrdu možete izabrati najviše jedne opcije.
DocType: Purchase Invoice,Get Advances Paid,Kreiraj avansno plaćanje
DocType: Item,Automatically Create New Batch,Automatski Create New Batch
DocType: Supplier,Represents Company,Predstavlja kompaniju
DocType: Student Admission,Admission Start Date,Prijem Ozljede Datum
DocType: Journal Entry,Total Amount in Words,Ukupan iznos riječima
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Novi zaposleni
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.,Došlo je do pogreške . Jedan vjerojatan razlog bi mogao biti da niste spremili obrazac. Molimo kontaktirajte support@erpnext.com ako se problem ne riješi .
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Moja košarica
apps/erpnext/erpnext/controllers/selling_controller.py +139,Order Type must be one of {0},Tip narudžbe mora biti jedan od {0}
DocType: Lead,Next Contact Date,Datum sledeceg kontaktiranja
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Otvaranje Kol
DocType: Healthcare Settings,Appointment Reminder,Pamćenje imenovanja
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +549,Please enter Account for Change Amount,Unesite račun za promjene Iznos
DocType: Program Enrollment Tool Student,Student Batch Name,Student Batch Ime
DocType: Holiday List,Holiday List Name,Naziv liste odmora
DocType: Repayment Schedule,Balance Loan Amount,Balance Iznos kredita
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +132,Added to details,Dodato na detalje
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Raspored predmeta
DocType: Budget,Applicable on Material Request,Primenljivo na zahtev za materijal
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +217,Stock Options,Stock Opcije
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +628,No Items added to cart,Nijedna stavka nije dodata u korpu
DocType: Journal Entry Account,Expense Claim,Rashodi polaganja
apps/erpnext/erpnext/assets/doctype/asset/asset.js +352,Do you really want to restore this scrapped asset?,Da li zaista želite da vratite ovaj ukinut imovine?
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +530,Qty for {0},Količina za {0}
DocType: Leave Application,Leave Application,Ostavite aplikaciju
DocType: Patient,Patient Relation,Relacija pacijenta
DocType: Item,Hub Category to Publish,Glavna kategorija za objavljivanje
DocType: Leave Block List,Leave Block List Dates,Ostavite datumi lista blokiranih
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +297,"Sales Order {0} has reservation for item {1}, you can
		only deliver reserved {1} against {0}. Serial No {2} cannot
		be delivered","Porudžbina prodaje {0} ima rezervaciju za stavku {1}, možete dostaviti samo rezervirano {1} na {0}. Serijski broj {2} se ne može isporučiti"
DocType: Sales Invoice,Billing Address GSTIN,Adresa za obračun GSTIN
DocType: Employee Tax Exemption Proof Submission,Total Eligible HRA Exemption,Ukupna prihvatljiva HRA izuzeća
DocType: Assessment Plan,Evaluate,Procijenite
DocType: Workstation,Net Hour Rate,Neto Hour Rate
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Sletio Trošak Kupnja Potvrda
DocType: Company,Default Terms,Uobičajeno Uvjeti
DocType: Supplier Scorecard Period,Criteria,Kriterijumi
DocType: Packing Slip Item,Packing Slip Item,Odreskom predmet
DocType: Purchase Invoice,Cash/Bank Account,Novac / bankovni račun
DocType: Travel Itinerary,Train,Voz
DocType: Healthcare Service Unit,Inpatient Occupancy,Bolničko stanovanje
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-YYYY.-
apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Navedite {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +74,Removed items with no change in quantity or value.,Ukloniti stavke bez promjene u količini ili vrijednosti.
DocType: Delivery Note,Delivery To,Dostava za
apps/erpnext/erpnext/stock/doctype/item/item.js +465,Variant creation has been queued.,Kreiranje varijante je stavljeno u red.
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +99,Work Summary for {0},Pregled radova za {0}
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Prvi dozvoljni otpust na listi biće postavljen kao podrazumevani Leave Approver.
apps/erpnext/erpnext/stock/doctype/item/item.py +754,Attribute table is mandatory,Atribut sto je obavezno
DocType: Production Plan,Get Sales Orders,Kreiraj narudžbe
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +69,{0} can not be negative,{0} ne može biti negativna
DocType: Training Event,Self-Study,Samo-studiranje
DocType: POS Closing Voucher,Period End Date,Datum završetka perioda
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27,Soil compositions do not add up to 100,Sastave zemljišta ne daju do 100
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +623,Discount,Popust
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {0}: {1} is required to create the Opening {2} Invoices,Red {0}: {1} je potreban za kreiranje Opening {2} faktura
DocType: Membership,Membership,Članstvo
DocType: Asset,Total Number of Depreciations,Ukupan broj Amortizacija
DocType: Sales Invoice Item,Rate With Margin,Stopu sa margina
DocType: Purchase Invoice,Is Return (Debit Note),Je povratak (obaveštenje o zaduživanju)
DocType: Workstation,Wages,Plata
DocType: Asset Maintenance,Maintenance Manager Name,Ime menadžera održavanja
DocType: Agriculture Task,Urgent,Hitan
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +187,Please specify a valid Row ID for row {0} in table {1},Molimo navedite važeću Row ID za redom {0} {1} u tabeli
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Nije moguće pronaći varijablu:
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +893,Please select a field to edit from numpad,Molimo izaberite polje za uređivanje iz numpad-a
apps/erpnext/erpnext/stock/doctype/item/item.py +279,Cannot be a fixed asset item as Stock Ledger is created.,Ne može biti osnovna stavka sredstva kao što je stvorena knjiga zaliha.
DocType: Subscription Plan,Fixed rate,Fiksna stopa
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js +7,Admit,Priznati
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Idite na radnu površinu i početi koristiti ERPNext
apps/erpnext/erpnext/templates/pages/order.js +31,Pay Remaining,Plati preostalo
DocType: Item,Manufacturer,Proizvođač
DocType: Landed Cost Item,Purchase Receipt Item,Kupnja Potvrda predmet
DocType: Leave Allocation,Total Leaves Encashed,Ukupno napušteno lišće
DocType: POS Profile,Sales Invoice Payment,Prodaja fakture za plaćanje
DocType: Quality Inspection Template,Quality Inspection Template Name,Kvalitetno ime za proveru kvaliteta
DocType: Project,First Email,Prva e-pošta
DocType: Company,Exception Budget Approver Role,Izuzetna budžetska uloga odobravanja
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date","Jednom podešen, ovaj račun će biti na čekanju do određenog datuma"
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervirano Warehouse u prodajni nalog / skladišta gotovih proizvoda
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Selling Amount,Prodaja Iznos
DocType: Repayment Schedule,Interest Amount,Iznos kamata
DocType: Sales Invoice,Loyalty Amount,Lojalnost
DocType: Employee Transfer,Employee Transfer Detail,Detalji transfera zaposlenih
DocType: Serial No,Creation Document No,Stvaranje dokumenata nema
DocType: Location,Location Details,Detalji o lokaciji
DocType: Share Transfer,Issue,Tiketi
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py +11,Records,Zapisi
DocType: Asset,Scrapped,odbačen
DocType: Item,Item Defaults,Item Defaults
DocType: Purchase Invoice,Returns,povraćaj
DocType: Job Card,WIP Warehouse,WIP Skladište
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Serijski Ne {0} je pod ugovorom za održavanje upto {1}
apps/erpnext/erpnext/config/hr.py +231,Recruitment,regrutacija
DocType: Lead,Organization Name,Naziv organizacije
DocType: Support Settings,Show Latest Forum Posts,Prikaži najnovije poruke foruma
DocType: Additional Salary Component,ASC-,ASC-
DocType: Tax Rule,Shipping State,State dostava
,Projected Quantity as Source,Projektovanih količina kao izvor
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,Stavka mora biti dodan pomoću 'Get stavki iz Kupovina Primici' gumb
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +911,Delivery Trip,Dostava putovanja
DocType: Student,A-,A-
DocType: Share Transfer,Transfer Type,Tip prenosa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +124,Sales Expenses,Prodajni troškovi
DocType: Diagnosis,Diagnosis,Dijagnoza
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standardna kupnju
DocType: Attendance Request,Explanation,Objašnjenje
DocType: GL Entry,Against,Protiv
DocType: Item Default,Sales Defaults,Sales Defaults
DocType: Sales Order Item,Work Order Qty,Work Order Količina
DocType: Item Default,Default Selling Cost Center,Zadani trošak prodaje
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +594,Disc,disk
DocType: Buying Settings,Material Transferred for Subcontract,Preneseni materijal za podugovaranje
DocType: Email Digest,Purchase Orders Items Overdue,Nalozi za kupovinu narudžbine
apps/erpnext/erpnext/accounts/page/pos/pos.js +1638,ZIP Code,Poštanski broj
apps/erpnext/erpnext/controllers/selling_controller.py +262,Sales Order {0} is {1},Prodajnog naloga {0} je {1}
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +256,Select interest income account in loan {0},Izaberete račun prihoda od kamata u pozajmici {0}
DocType: Opportunity,Contact Info,Kontakt Informacije
apps/erpnext/erpnext/config/stock.py +322,Making Stock Entries,Izrada Stock unosi
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py +15,Cannot promote Employee with status Left,Ne može promovirati zaposlenika sa statusom levo
DocType: Packing Slip,Net Weight UOM,Težina mjerna jedinica
DocType: Item Default,Default Supplier,Glavni dobavljač
DocType: Loan,Repayment Schedule,otplata Raspored
DocType: Shipping Rule Condition,Shipping Rule Condition,Uslov pravila transporta
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py +19,End Date can not be less than Start Date,Datum završetka ne može biti manja od početnog datuma
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +250,Invoice can't be made for zero billing hour,Faktura ne može biti napravljena za nultu cenu fakturisanja
DocType: Company,Date of Commencement,Datum početka
DocType: Sales Person,Select company name first.,Prvo odaberite naziv preduzeća.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +204,Email sent to {0},E-mail poslan na {0}
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Ponude dobijene od dobavljača.
apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Zamijenite BOM i ažurirajte najnoviju cijenu u svim BOM
apps/erpnext/erpnext/controllers/selling_controller.py +28,To {0} | {1} {2},Za {0} | {1} {2}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js +13,This is a root supplier group and cannot be edited.,Ovo je korenska grupa dobavljača i ne može se uređivati.
DocType: Delivery Note,Driver Name,Ime vozača
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Average Age,Prosječna starost
DocType: Education Settings,Attendance Freeze Date,Posjećenost Freeze Datum
DocType: Payment Request,Inward,Unutra
apps/erpnext/erpnext/utilities/user_progress.py +110,List a few of your suppliers. They could be organizations or individuals.,Navedite nekoliko svojih dobavljača. Oni mogu biti tvrtke ili fizičke osobe.
apps/erpnext/erpnext/templates/pages/home.html +32,View All Products,Pogledaj sve proizvode
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimalna Olovo Starost (Dana)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60,All BOMs,Svi sastavnica
DocType: Company,Parent Company,Matična kompanija
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Sobe Hotela tipa {0} nisu dostupne na {1}
DocType: Healthcare Practitioner,Default Currency,Zadana valuta
apps/erpnext/erpnext/controllers/selling_controller.py +147,Maximum discount for Item {0} is {1}%,Maksimalni popust za stavku {0} je {1}%
DocType: Asset Movement,From Employee,Od zaposlenika
DocType: Driver,Cellphone Number,Broj mobitela
DocType: Project,Monitor Progress,Napredak monitora
apps/erpnext/erpnext/controllers/accounts_controller.py +529,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Upozorenje : Sustav neće provjeravati overbilling od iznosa za točku {0} u {1} je nula
DocType: Journal Entry,Make Difference Entry,Čine razliku Entry
DocType: Supplier Quotation,Auto Repeat Section,Auto Repeat Odjeljak
DocType: Upload Attendance,Attendance From Date,Gledatelja Od datuma
DocType: Appraisal Template Goal,Key Performance Area,Područje djelovanja
DocType: Program Enrollment,Transportation,Prevoznik
apps/erpnext/erpnext/controllers/item_variant.py +94,Invalid Attribute,Invalid Atributi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,{0} {1} must be submitted,{0} {1} mora biti podnesen
DocType: Buying Settings,Default Supplier Group,Podrazumevana grupa dobavljača
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,Quantity must be less than or equal to {0},Količina mora biti manji ili jednak {0}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +42,Maximum amount eligible for the component {0} exceeds {1},Maksimalni iznos koji odgovara komponenti {0} prelazi {1}
DocType: Department Approver,Department Approver,Odjel Odobrenja
DocType: SMS Center,Total Characters,Ukupno Likovi
DocType: Employee Advance,Claimed,Tvrdio
DocType: Crop,Row Spacing,Razmak redova
apps/erpnext/erpnext/controllers/buying_controller.py +192,Please select BOM in BOM field for Item {0},Molimo odaberite BOM BOM u polje za Stavka {0}
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +22,There isn't any item variant for the selected item,Za izabranu stavku nema nijedne varijante stavki
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Obrazac Račun Detalj
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Pomirenje Plaćanje fakture
DocType: Clinical Procedure,Procedure Template,Šablon procedure
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +75,Contribution %,Doprinos%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +243,"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}","Prema Kupnja Postavke ako Narudžbenice željeni == &#39;DA&#39;, onda za stvaranje fakturi, korisnik treba prvo stvoriti Narudžbenice za stavku {0}"
,HSN-wise-summary of outward supplies,HSN-mudar-rezime izvora isporuke
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Porezni brojevi itd.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +261,To State,Držati
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +145,Distributor,Distributer
DocType: Asset Finance Book,Asset Finance Book,Asset Finance Book
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Košarica Shipping pravilo
apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Molimo podesite &#39;primijeniti dodatne popusta na&#39;
DocType: Party Tax Withholding Config,Applicable Percent,Veliki procenat
,Ordered Items To Be Billed,Naručeni artikli za naplatu
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Od opseg mora biti manji od u rasponu
DocType: Global Defaults,Global Defaults,Globalne zadane postavke
apps/erpnext/erpnext/projects/doctype/project/project.py +291,Project Collaboration Invitation,Projekt Collaboration Poziv
DocType: Salary Slip,Deductions,Odbici
DocType: Setup Progress Action,Action Name,Naziv akcije
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +17,Start Year,Početak godine
apps/erpnext/erpnext/regional/india/utils.py +28,First 2 digits of GSTIN should match with State number {0},Prva 2 cifre GSTIN treba se podudarati s državnim broj {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +81,PDC/LC,PDC / LC
DocType: Purchase Invoice,Start date of current invoice's period,Početak datum tekućeg razdoblja dostavnice
DocType: Salary Slip,Leave Without Pay,Ostavite bez plaće
DocType: Payment Request,Outward,Napolju
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,Kapaciteta za planiranje Error
,Trial Balance for Party,Suđenje Balance za stranke
DocType: Lead,Consultant,Konsultant
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356,Parents Teacher Meeting Attendance,Prisustvo sastanaka učitelja roditelja
DocType: Salary Slip,Earnings,Zarada
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +534,Finished Item {0} must be entered for Manufacture type entry,Završio Stavka {0} mora biti unesen za tip Proizvodnja unos
apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Otvaranje Računovodstvo Balance
,GST Sales Register,PDV prodaje Registracija
DocType: Sales Invoice Advance,Sales Invoice Advance,Predujam prodajnog računa
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,Ništa se zatražiti
DocType: Stock Settings,Default Return Warehouse,Default Return Warehouse
apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Izaberite svoje domene
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py +228,Shopify Supplier,Shopify Supplier
DocType: Bank Statement Transaction Entry,Payment Invoice Items,Stavke fakture za plaćanje
DocType: Payroll Entry,Employee Details,Zaposlenih Detalji
DocType: Amazon MWS Settings,CN,CN
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Polja će se kopirati samo u trenutku kreiranja.
DocType: Setup Progress Action,Domains,Domena
apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date',"' Stvarni datum početka ' ne može biti veći od stvarnog datuma završetka """
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +359,Management,upravljanje
DocType: Cheque Print Template,Payer Settings,Payer Postavke
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +644,No pending Material Requests found to link for the given items.,Nema traženih materijala koji su pronađeni za povezivanje za date stavke.
apps/erpnext/erpnext/public/js/utils/party.js +193,Select company first,Prvo odaberite kompaniju
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""","Ovo će biti dodan na Šifra za varijantu. Na primjer, ako je vaš skraćenica ""SM"", a stavka kod je ""T-SHIRT"", stavka kod varijante će biti ""T-SHIRT-SM"""
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Neto plaća (riječima) će biti vidljiva nakon što spremite klizne plaće.
DocType: Delivery Note,Is Return,Je li povratak
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +89,Caution,Oprez
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17,Start day is greater than end day in task '{0}',Dan početka je veći od kraja dana u zadatku &#39;{0}&#39;
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +886,Return / Debit Note,Povratak / Debit Napomena
DocType: Price List Country,Price List Country,Cijena Lista država
DocType: Item,UOMs,UOMs
apps/erpnext/erpnext/stock/utils.py +236,{0} valid serial nos for Item {1},{0} valjani serijski broj za artikal {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +61,Item Code cannot be changed for Serial No.,Kod artikla ne može se mijenjati za serijski broj.
DocType: Purchase Invoice Item,UOM Conversion Factor,UOM konverzijski faktor
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js +9,Please enter Item Code to get Batch Number,Unesite Šifra da Batch Broj
DocType: Loyalty Point Entry,Loyalty Point Entry,Ulaz lojalnosti
DocType: Stock Settings,Default Item Group,Zadana grupa proizvoda
DocType: Job Card,Time In Mins,Vrijeme u minutima
apps/erpnext/erpnext/config/non_profit.py +93,Grant information.,Grant informacije.
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Šifarnik dobavljača
DocType: Contract Template,Contract Terms and Conditions,Uslovi i uslovi ugovora
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +415,You cannot restart a Subscription that is not cancelled.,Ne možete ponovo pokrenuti pretplatu koja nije otkazana.
DocType: Account,Balance Sheet,Završni račun
DocType: Leave Type,Is Earned Leave,Da li ste zarađeni?
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +797,Cost Center For Item with Item Code ',Troška Za Stavke sa Šifra '
DocType: Fee Validity,Valid Till,Valid Till
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Ukupno sastanak učitelja roditelja
apps/erpnext/erpnext/accounts/page/pos/pos.js +2527,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",Način plaćanja nije konfiguriran. Molimo provjerite da li račun je postavljena o načinu plaćanja ili na POS profilu.
apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Isti stavka ne može se upisati više puta.
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","Dalje računa može biti pod Grupe, ali unosa može biti protiv ne-Grupe"
DocType: Lead,Lead,Potencijalni kupac
DocType: Email Digest,Payables,Obveze
DocType: Course,Course Intro,Naravno Intro
DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Stock Entry {0} stvorio
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +110,You don't have enought Loyalty Points to redeem,Ne iskoristite Loyalty Points za otkup
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py +23,Please set associated account in Tax Withholding Category {0} against Company {1},Molimo da podesite pridruženi račun u Kategorija za odbijanje poreza {0} protiv Kompanije {1}
apps/erpnext/erpnext/controllers/buying_controller.py +393,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Odbijena Količina ne može unijeti u Kupovina Povratak
apps/erpnext/erpnext/stock/doctype/item/item.js +197,Changing Customer Group for the selected Customer is not allowed.,Promena klijentske grupe za izabranog klijenta nije dozvoljena.
,Purchase Order Items To Be Billed,Narudžbenica Proizvodi se naplaćuje
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +71,Updating estimated arrival times.,Ažuriranje procijenjenih vremena dolaska.
DocType: Program Enrollment Tool,Enrollment Details,Detalji upisa
DocType: Purchase Invoice Item,Net Rate,Neto stopa
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +194,Please select a customer,Izaberite kupca
DocType: Leave Policy,Leave Allocations,Ostavite dodelu
DocType: Purchase Invoice Item,Purchase Invoice Item,Narudzbine stavki
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,Stock Ledger unosi i GL unosi se ponovo postavila za odabrane Kupovina Primici
DocType: Student Report Generation Tool,Assessment Terms,Uslovi za procjenu
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Stavku 1
DocType: Holiday,Holiday,Odmor
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +25,Leave Type is madatory,Leave Type je lijevan
DocType: Support Settings,Close Issue After Days,Zatvori Issue Nakon nekoliko dana
,Eway Bill,Eway Bill
apps/erpnext/erpnext/public/js/hub/marketplace.js +139,You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,Morate biti korisnik sa ulogama System Manager i Item Manager da biste dodali korisnike u Marketplace.
DocType: Leave Control Panel,Leave blank if considered for all branches,Ostavite prazno ako smatra za sve grane
DocType: Job Opening,Staffing Plan,Plan zapošljavanja
DocType: Bank Guarantee,Validity in Days,Valjanost u Dani
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-forma nije primjenjiv za fakture: {0}
DocType: Certified Consultant,Name of Consultant,Ime konsultanta
DocType: Payment Reconciliation,Unreconciled Payment Details,Nesaglašen Detalji plaćanja
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Član Aktivnost
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,kako Count
DocType: Global Defaults,Current Fiscal Year,Tekuće fiskalne godine
DocType: Purchase Invoice,Group same items,Grupa iste stavke
DocType: Purchase Invoice,Disable Rounded Total,Ugasiti zaokruženi iznos
DocType: Marketplace Settings,Sync in Progress,Sinhronizacija u toku
DocType: Department,Parent Department,Odeljenje roditelja
DocType: Loan Application,Repayment Info,otplata Info
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +486,'Entries' cannot be empty,' Prijave ' ne može biti prazno
DocType: Maintenance Team Member,Maintenance Role,Uloga održavanja
apps/erpnext/erpnext/utilities/transaction_base.py +86,Duplicate row {0} with same {1},Dupli red {0} sa istim {1}
DocType: Marketplace Settings,Disable Marketplace,Onemogući tržište
,Trial Balance,Pretresno bilanca
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463,Fiscal Year {0} not found,Fiskalna godina {0} nije pronađen
apps/erpnext/erpnext/config/hr.py +394,Setting up Employees,Postavljanje Zaposlenih
DocType: Hotel Room Reservation,Hotel Reservation User,Rezervacija korisnika hotela
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +165,Please select prefix first,Odaberite prefiks prvi
DocType: Contract,Fulfilment Deadline,Rok ispunjenja
DocType: Student,O-,O-
DocType: Subscription Settings,Subscription Settings,Podešavanja pretplate
DocType: Purchase Invoice,Update Auto Repeat Reference,Ažurirajte Auto Repeat Reference
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +274,Optional Holiday List not set for leave period {0},Opciona lista letenja nije postavljena za period odmora {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +165,Research,istraživanje
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +243,To Address 2,Na adresu 2
DocType: Maintenance Visit Purpose,Work Done,Rad Done
apps/erpnext/erpnext/controllers/item_variant.py +35,Please specify at least one attribute in the Attributes table,Molimo navedite barem jedan atribut atribute tabeli
DocType: Announcement,All Students,Svi studenti
apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Item {0} must be a non-stock item,Stavka {0} mora biti ne-stock stavka
apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Pogledaj Ledger
DocType: Grading Scale,Intervals,intervali
DocType: Bank Statement Transaction Entry,Reconciled Transactions,Usklađene transakcije
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +42,Earliest,Najstarije
DocType: Crop Cycle,Linked Location,Povezana lokacija
apps/erpnext/erpnext/stock/doctype/item/item.py +543,"An Item Group exists with same name, please change the item name or rename the item group","Stavka Grupa postoji s istim imenom , molimo promijenite ime stavku ili preimenovati stavku grupe"
DocType: Crop Cycle,Less than a year,Manje od godinu dana
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +106,Rest Of The World,Ostatak svijeta
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Stavka {0} ne može imati Batch
DocType: Crop,Yield UOM,Primarni UOM
,Budget Variance Report,Proračun varijance Prijavi
DocType: Salary Slip,Gross Pay,Bruto plaća
DocType: Item,Is Item from Hub,Je stavka iz Hub-a
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1638,Get Items from Healthcare Services,Uzmite predmete iz zdravstvenih usluga
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +112,Row {0}: Activity Type is mandatory.,Red {0}: Aktivnost Tip je obavezno.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +176,Dividends Paid,Isplaćene dividende
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +39,Accounting Ledger,Računovodstvo Ledger
DocType: Asset Value Adjustment,Difference Amount,Razlika Iznos
DocType: Purchase Invoice,Reverse Charge,Reverse Charge
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +182,Retained Earnings,Zadržana dobit
DocType: Job Card,Timing Detail,Detalji vremena
DocType: Purchase Invoice,05-Change in POS,05-Promena u POS
DocType: Vehicle Log,Service Detail,Servis Detail
DocType: BOM,Item Description,Opis artikla
DocType: Student Sibling,Student Sibling,student Polubrat
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +20,Payment Mode,Način plaćanja
DocType: Purchase Invoice,Supplied Items,Isporučenog pribora
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Molimo aktivirajte meni za restoran {0}
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +81,Commission Rate %,Procenat Komisije%
DocType: Work Order,Qty To Manufacture,Količina za proizvodnju
DocType: Email Digest,New Income,novi prihod
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Održavanje istu stopu tijekom kupnje ciklusa
DocType: Opportunity Item,Opportunity Item,Poslovna prilika artikla
,Student and Guardian Contact Details,Student i Guardian Kontakt detalji
apps/erpnext/erpnext/accounts/doctype/account/account.js +51,Merge Account,Merge Account
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53,Row {0}: For supplier {0} Email Address is required to send email,Red {0}: Za dobavljač {0}-mail adresa je potrebno za slanje e-mail
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +76,Temporary Opening,Privremeno Otvaranje
,Employee Leave Balance,Zaposlenik napuste balans
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +148,Balance for Account {0} must always be {1},Bilans konta {0} uvijek mora biti {1}
DocType: Patient Appointment,More Info,Više informacija
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +181,Valuation Rate required for Item in row {0},Vrednovanje potrebne za Stavka u nizu objekta {0}
DocType: Supplier Scorecard,Scorecard Actions,Action Scorecard
apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Masters in Computer Science,Primer: Masters u Computer Science
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +67,Supplier {0} not found in {1},Dobavljač {0} nije pronađen u {1}
DocType: Purchase Invoice,Rejected Warehouse,Odbijen galerija
DocType: GL Entry,Against Voucher,Protiv Voucheru
DocType: Item Default,Default Buying Cost Center,Zadani trošak kupnje
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.","Da biste dobili najbolje iz ERPNext, preporučujemo vam da malo vremena i gledati ove snimke pomoć."
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1033,For Default Supplier (optional),Za podrazumevani dobavljač
DocType: Supplier Quotation Item,Lead Time in days,Potencijalni kupac u danima
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +82,Accounts Payable Summary,Računi se plaćaju Sažetak
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +214,Not authorized to edit frozen Account {0},Nije ovlašten za uređivanje smrznute račun {0}
DocType: Journal Entry,Get Outstanding Invoices,Kreiraj neplaćene račune
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Prodajnog naloga {0} nije ispravan
DocType: Supplier Scorecard,Warn for new Request for Quotations,Upozorite na novi zahtev za citate
apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Narudžbenice vam pomoći planirati i pratiti na kupovinu
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +146,Lab Test Prescriptions,Testiranje laboratorijskih testova
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +164,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Ukupne emisije / Transfer količina {0} u Industrijska Zahtjev {1} \ ne može biti veća od tražene količine {2} za Stavka {3}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +172,Small,Mali
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Ako Shopify ne sadrži kupca u porudžbini, tada će sinhronizirati naloge, sistem će razmatrati podrazumevani kupac za porudžbinu"
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Stavka o otvaranju fakture kreiranja stavke
DocType: Cashier Closing Payments,Cashier Closing Payments,Plaćanje plaćanja blagajnika
DocType: Education Settings,Employee Number,Broj radnika
DocType: Subscription Settings,Cancel Invoice After Grace Period,Otkaži fakturu nakon grejs perioda
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Slučaj Ne ( i) je već u uporabi . Pokušajte s predmetu broj {0}
DocType: Project,% Completed,Završen%
,Invoiced Amount (Exculsive Tax),Dostavljeni iznos ( Exculsive poreza )
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Stavku 2
DocType: Travel Request,International,International
DocType: Training Event,Training Event,treningu
DocType: Item,Auto re-order,Autorefiniš reda
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Ukupno Ostvareni
DocType: Employee,Place of Issue,Mjesto izdavanja
DocType: Contract,Contract,ugovor
DocType: Plant Analysis,Laboratory Testing Datetime,Laboratorijsko ispitivanje Datetime
DocType: Email Digest,Add Quote,Dodaj Citat
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1242,UOM coversion factor required for UOM: {0} in Item: {1},UOM faktor coversion potrebna za UOM: {0} u točki: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Indirect Expenses,Neizravni troškovi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +128,Row {0}: Qty is mandatory,Red {0}: Količina je obvezno
DocType: Agriculture Analysis Criteria,Agriculture,Poljoprivreda
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +15,Create Sales Order,Kreirajte porudžbinu
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +510,Accounting Entry for Asset,Računovodstveni unos za imovinu
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +871,Block Invoice,Blok faktura
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js +16,Quantity to Make,Količina koju treba napraviti
apps/erpnext/erpnext/accounts/page/pos/pos.js +801,Sync Master Data,Sync Master Data
DocType: Asset Repair,Repair Cost,Troškovi popravki
apps/erpnext/erpnext/utilities/user_progress.py +138,Your Products or Services,Vaši proizvodi ili usluge
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Neuspešno se prijaviti
apps/erpnext/erpnext/controllers/buying_controller.py +617,Asset {0} created,Sredstvo {0} kreirano
DocType: Special Test Items,Special Test Items,Specijalne testne jedinice
apps/erpnext/erpnext/public/js/hub/marketplace.js +102,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,Potrebno je da budete korisnik sa ulogama System Manager i Item Manager za prijavljivanje na Marketplace.
DocType: Bank Statement Transaction Payment Item,Mode of Payment,Način plaćanja
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +25,As per your assigned Salary Structure you cannot apply for benefits,Prema vašoj dodeljenoj strukturi zarada ne možete se prijaviti za naknade
apps/erpnext/erpnext/stock/doctype/item/item.py +217,Website Image should be a public file or website URL,Sajt slika treba da bude javni datoteke ili web stranice URL
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +71,This is a root item group and cannot be edited.,To jekorijen stavka grupa i ne može se mijenjati .
apps/erpnext/erpnext/accounts/doctype/account/account.js +133,Merge,Spoji se
DocType: Journal Entry Account,Purchase Order,Narudžbenica
DocType: Vehicle,Fuel UOM,gorivo UOM
DocType: Warehouse,Warehouse Contact Info,Kontakt informacije skladišta
DocType: Payment Entry,Write Off Difference Amount,Otpis Razlika Iznos
DocType: Volunteer,Volunteer Name,Ime volontera
apps/erpnext/erpnext/controllers/accounts_controller.py +777,Rows with duplicate due dates in other rows were found: {0},Redovi sa dupliciranim datumima u drugim redovima su pronađeni: {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +535,"{0}: Employee email not found, hence email not sent",{0}: e-mail nije poslat jer e-mail zaposlenog nije pronađen
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +55,No Salary Structure assigned for Employee {0} on given date {1},Struktura zarada nije dodeljena zaposlenom {0} na datom datumu {1}
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Pravilo o isporuci ne važi za zemlju {0}
DocType: Item,Foreign Trade Details,Vanjske trgovine Detalji
,Assessment Plan Status,Status plana procjene
DocType: Email Digest,Annual Income,Godišnji prihod
DocType: Serial No,Serial No Details,Serijski nema podataka
DocType: Purchase Invoice Item,Item Tax Rate,Poreska stopa artikla
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +176,From Party Name,Od imena partije
DocType: Student Group Student,Group Roll Number,Grupa Roll Broj
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +177,"For {0}, only credit accounts can be linked against another debit entry","Za {0}, samo kredit računa može biti povezan protiv drugog ulaska debit"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +659,Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena
apps/erpnext/erpnext/stock/get_item_details.py +167,Item {0} must be a Sub-contracted Item,Stavka {0} mora bitisklopljen ugovor artikla
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Capital Equipments,Kapitalni oprema
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.","Cijene Pravilo prvo se bira na temelju 'Nanesite na' terenu, koji može biti točka, točka Grupa ili Brand."
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +372,Please set the Item Code first,Molimo prvo postavite kod za stavku
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +157,Doc Type,Doc tip
apps/erpnext/erpnext/controllers/selling_controller.py +132,Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100
DocType: Subscription Plan,Billing Interval Count,Interval broja obračuna
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py +10,Appointments and Patient Encounters,Imenovanja i susreti sa pacijentom
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +135,Value missing,Nedostaje vrijednost
DocType: Employee,Department and Grade,Odeljenje i razred
DocType: Sales Invoice Item,Edit Description,Uredi opis
DocType: Antibiotic,Antibiotic,Antibiotik
,Team Updates,Team Updates
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +39,For Supplier,za Supplier
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Postavljanje Vrsta računa pomaže u odabiru ovaj račun u prometu.
DocType: Purchase Invoice,Grand Total (Company Currency),Sveukupno (valuta tvrtke)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Napravi Print Format
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Kreirana naknada
apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Nije našao bilo koji predmet pod nazivom {0}
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js +8,Items Filter,Filter predmeta
DocType: Supplier Scorecard Criteria,Criteria Formula,Kriterijum Formula
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Ukupno Odlazni
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""","Tu može biti samo jedan Dostava Pravilo Stanje sa 0 ili prazni vrijednost za "" Da Value """
DocType: Bank Statement Transaction Settings Item,Transaction,Transakcija
DocType: Patient Appointment,Duration,Trajanje
apps/erpnext/erpnext/controllers/status_updater.py +160,"For an item {0}, quantity must be positive number","Za stavku {0}, količina mora biti pozitivni broj"
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +76,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Napomena : Ovaj troška jegrupa . Ne mogu napraviti računovodstvenih unosa protiv skupine .
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +44,Compensatory leave request days not in valid holidays,Dane zahtjeva za kompenzacijski odmor ne važe u valjanim praznicima
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53,Child warehouse exists for this warehouse. You can not delete this warehouse.,skladište dijete postoji za to skladište. Ne možete brisati ovo skladište.
DocType: Item,Website Item Groups,Website Stavka Grupe
DocType: Purchase Invoice,Total (Company Currency),Ukupno (Company valuta)
DocType: Daily Work Summary Group,Reminder,Podsjetnik
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +304,Accessable Value,Dostupna vrednost
apps/erpnext/erpnext/stock/utils.py +231,Serial number {0} entered more than once,Serijski broj {0} ušao više puta
DocType: Bank Statement Transaction Invoice Item,Journal Entry,Časopis Stupanje
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +183,From GSTIN,Iz GSTIN-a
DocType: Expense Claim Advance,Unclaimed amount,Neobjavljeni iznos
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +269,{0} items in progress,{0} stavke u tijeku
DocType: Workstation,Workstation Name,Ime Workstation
DocType: Grading Scale Interval,Grade Code,Grade Kod
DocType: POS Item Group,POS Item Group,POS Stavka Group
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Email Digest:
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +23,Alternative item must not be same as item code,Alternativni predmet ne sme biti isti kao kod stavke
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +638,BOM {0} does not belong to Item {1},BOM {0} ne pripada Stavka {1}
DocType: Sales Partner,Target Distribution,Ciljana Distribucija
DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Završetak privremene procjene
DocType: Salary Slip,Bank Account No.,Žiro račun broj
DocType: Naming Series,This is the number of the last created transaction with this prefix,To je broj zadnjeg stvorio transakcije s ovim prefiksom
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)
","Može se koristiti varijable Scorecard, kao i: {total_score} (ukupna ocjena iz tog perioda), {period_number} (broj perioda za današnji dan)"
apps/erpnext/erpnext/public/js/setup_wizard.js +254,Collapse All,Skupi sve
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +27,Create Purchase Order,Kreirajte narudžbinu
DocType: Quality Inspection Reading,Reading 8,Čitanje 8
DocType: Inpatient Record,Discharge Note,Napomena o pražnjenju
DocType: Purchase Invoice,Taxes and Charges Calculation,Porezi i naknade Proračun
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Knjiga imovine Amortizacija Entry Automatski
DocType: BOM Operation,Workstation,Workstation
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Zahtjev za ponudu dobavljač
DocType: Healthcare Settings,Registration Message,Poruka za upis
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,Hardware,Hardver
DocType: Prescription Dosage,Prescription Dosage,Dosage na recept
DocType: Contract,HR Manager,Šef ljudskih resursa
apps/erpnext/erpnext/accounts/party.py +196,Please select a Company,Molimo odaberite poduzeća
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +95,Privilege Leave,Privilege dopust
DocType: Purchase Invoice,Supplier Invoice Date,Dobavljač Datum fakture
DocType: Asset Settings,This value is used for pro-rata temporis calculation,Ova vrijednost se koristi za izračun pro-rata temporis
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +91,You need to enable Shopping Cart,Trebate omogućiti Košarica
DocType: Payment Entry,Writeoff,Otpisati
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-YYYY.-
DocType: Stock Settings,Naming Series Prefix,Prefiks naziva serije
DocType: Appraisal Template Goal,Appraisal Template Goal,Procjena Predložak cilja
DocType: Salary Component,Earning,Zarada
DocType: Supplier Scorecard,Scoring Criteria,Kriteriji bodovanja
DocType: Purchase Invoice,Party Account Currency,Party računa valuta
,BOM Browser,BOM Browser
apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Molimo ažurirajte svoj status za ovaj trening događaj
DocType: Item Barcode,EAN,EAN
DocType: Purchase Taxes and Charges,Add or Deduct,Zbrajanje ili oduzimanje
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Preklapanje uvjeti nalaze između :
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +188,Against Journal Entry {0} is already adjusted against some other voucher,Protiv Journal Entry {0} je već prilagođen protiv nekih drugih vaučer
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Ukupna vrijednost Order
apps/erpnext/erpnext/demo/setup/setup_data.py +322,Food,Hrana
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +69,Ageing Range 3,Starenje Range 3
DocType: POS Closing Voucher Details,POS Closing Voucher Details,POS Closing Voucher Detalji
DocType: Shopify Log,Shopify Log,Shopify Log
DocType: Inpatient Occupancy,Check In,Provjeri
DocType: Maintenance Schedule Item,No of Visits,Bez pregleda
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Održavanje Raspored {0} postoji protiv {1}
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,upisa student
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Valuta zatvaranja računa mora biti {0}
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Zbir bodova za sve ciljeve bi trebao biti 100. To je {0}
DocType: Project,Start and End Dates,Datume početka i završetka
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,Uslovi ispunjavanja obrasca ugovora
,Delivered Items To Be Billed,Isporučeni proizvodi za naplatiti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Otvorena BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +64,Warehouse cannot be changed for Serial No.,Skladište se ne može promijeniti za serijskog broja
DocType: Authorization Rule,Average Discount,Prosječni popust
DocType: Project Update,Great/Quickly,Odlično / brzo
DocType: Purchase Invoice Item,UOM,UOM
DocType: Employee Tax Exemption Declaration,Annual HRA Exemption,Godišnja HRA izuzeća
DocType: Rename Tool,Utilities,Komunalne usluge
DocType: POS Profile,Accounting,Računovodstvo
DocType: Asset,Purchase Receipt Amount,Iznos kupoprodajnog iznosa
DocType: Employee Separation,Exit Interview Summary,Izlaz iz intervjua
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select batches for batched item ,Molimo odaberite serija za dozirana stavku
DocType: Asset,Depreciation Schedules,Amortizacija rasporedi
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +37,"Support for public app is deprecated. Please setup private app, for more details refer user manual","Podrška za javnu aplikaciju je zastarjela. Molimo, podesite privatnu aplikaciju, za više detalja pogledajte korisničko uputstvo"
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,Following accounts might be selected in GST Settings:,Sledeći nalogi mogu biti izabrani u GST Podešavanja:
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +104,Application period cannot be outside leave allocation period,Period aplikacija ne može biti razdoblje raspodjele izvan odsustva
DocType: Activity Cost,Projects,Projekti
DocType: Payment Request,Transaction Currency,transakcija valuta
apps/erpnext/erpnext/controllers/buying_controller.py +33,From {0} | {1} {2},Od {0} | {1} {2}
apps/erpnext/erpnext/public/js/hub/marketplace.js +164,Some emails are invalid,Neki e-mailovi su nevažeći
DocType: Work Order Operation,Operation Description,Operacija Opis
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.,Ne možete promijeniti fiskalnu godinu datum početka i datum završetka fiskalne godine kada Fiskalna godina se sprema.
DocType: Quotation,Shopping Cart,Korpa
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Avg Daily Odlazni
DocType: POS Profile,Campaign,Kampanja
DocType: Supplier,Name and Type,Naziv i tip
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +64,Approval Status must be 'Approved' or 'Rejected',"Status Odobrenje mora biti ""Odobreno"" ili "" Odbijeno """
DocType: Healthcare Practitioner,Contacts and Address,Kontakti i adresa
DocType: Salary Structure,Max Benefits (Amount),Maksimalne prednosti (iznos)
DocType: Purchase Invoice,Contact Person,Kontakt osoba
apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date',""" Očekivani datum početka ' ne može biti veći od očekivanog datuma završetka"""
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +107,No data for this period,Nema podataka za ovaj period
DocType: Course Scheduling Tool,Course End Date,Naravno Završni datum
DocType: Holiday List,Holidays,Praznici
DocType: Sales Order Item,Planned Quantity,Planirana količina
DocType: Purchase Invoice Item,Item Tax Amount,Iznos poreza artikla
DocType: Water Analysis,Water Analysis Criteria,Kriterijumi za analizu vode
DocType: Item,Maintain Stock,Održavati Stock
DocType: Employee,Prefered Email,Prefered mail
DocType: Student Admission,Eligibility and Details,Prihvatljivost i Detalji
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +92,Net Change in Fixed Asset,Neto promjena u fiksnoj Asset
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +38,Reqd Qty,Reqd Qty
DocType: Leave Control Panel,Leave blank if considered for all designations,Ostavite prazno ako smatra za sve oznake
apps/erpnext/erpnext/controllers/accounts_controller.py +876,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Punjenje tipa ' Stvarni ' u redu {0} ne mogu biti uključeni u točki Rate
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +531,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Od datuma i vremena
DocType: Shopify Settings,For Company,Za tvrtke
apps/erpnext/erpnext/config/support.py +17,Communication log.,Dnevni pregled komunikacije
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195,"Request for Quotation is disabled to access from portal, for more check portal settings.","Zahtjev za ponudu je onemogućen pristup iz portala, za više postavki portal ček."
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Dobavljač Scorecard Scoring Variable
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Buying Amount,Iznos nabavke
DocType: POS Closing Voucher,Modes of Payment,Načini plaćanja
DocType: Sales Invoice,Shipping Address Name,Dostava adresa Ime
DocType: Material Request,Terms and Conditions Content,Uvjeti sadržaj
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Bilo je grešaka u kreiranju rasporeda kursa
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,Prvi Expens Approver na listi biće postavljen kao podrazumevani Expens Approver.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +611,cannot be greater than 100,ne može biti veća od 100
apps/erpnext/erpnext/public/js/hub/marketplace.js +97,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,Morate biti korisnik osim administratora sa ulogama upravitelja sistema i menadžera postavki za registraciju na tržištu.
apps/erpnext/erpnext/stock/doctype/item/item.py +810,Item {0} is not a stock Item,Stavka {0} nijestock Stavka
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-YYYY.-
DocType: Maintenance Visit,Unscheduled,Neplanski
DocType: Employee,Owned,U vlasništvu
DocType: Salary Component,Depends on Leave Without Pay,Ovisi o neplaćeni odmor
DocType: Pricing Rule,"Higher the number, higher the priority","Veći broj, veći prioritet"
,Purchase Invoice Trends,Trendovi kupnje proizvoda
DocType: Employee,Better Prospects,Bolji izgledi
DocType: Travel Itinerary,Gluten Free,Bez glutena
DocType: Loyalty Program Collection,Minimum Total Spent,Minimalno ukupno potrošeno
apps/erpnext/erpnext/stock/doctype/batch/batch.py +222,"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","Row # {0}: Odgovor batch {1} ima samo {2} Količina. Molimo odaberite neku drugu seriju koja ima {3} Količina dostupna ili podijeliti red u više redova, za isporuku / pitanje iz više serija"
DocType: Loyalty Program,Expiry Duration (in days),Trajanje isteka (u danima)
DocType: Inpatient Record,Discharge Date,Datum otpustanja
DocType: Subscription Plan,Price Determination,Određivanje cene
DocType: Vehicle,License Plate,registarska tablica
apps/erpnext/erpnext/hr/doctype/department/department_tree.js +18,New Department,Novo odjeljenje
DocType: Compensatory Leave Request,Worked On Holiday,Radili na odmoru
DocType: Appraisal,Goals,Golovi
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399,Select POS Profile,Izaberite POS profil
DocType: Warranty Claim,Warranty / AMC Status,Jamstveni / AMC Status
,Accounts Browser,Šifrarnik konta
DocType: Procedure Prescription,Referral,Upućivanje
DocType: Payment Entry Reference,Payment Entry Reference,Plaćanje Entry Reference
DocType: GL Entry,GL Entry,GL ulaz
DocType: Support Search Source,Response Options,Opcije odgovora
DocType: HR Settings,Employee Settings,Postavke zaposlenih
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html +13,Loading Payment System,Uplata platnog sistema
,Batch-Wise Balance History,Batch-Wise bilanca Povijest
apps/erpnext/erpnext/controllers/accounts_controller.py +1064,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,Red # {0}: Ne može se podesiti Rate ako je iznos veći od fakturisane količine za stavku {1}.
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,podešavanja print ažuriran u odgovarajućim formatu print
DocType: Package Code,Package Code,paket kod
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +108,Apprentice,šegrt
DocType: Purchase Invoice,Company GSTIN,kompanija GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +106,Negative Quantity is not allowed,Negativna količina nije dopuštena
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Porez detalj stol učitani iz stavka master kao string i pohranjeni u ovoj oblasti.
 Koristi se za poreza i naknada"
apps/erpnext/erpnext/hr/doctype/employee/employee.py +164,Employee cannot report to himself.,Zaposleni ne može prijaviti samog sebe.
DocType: Leave Type,Max Leaves Allowed,Maksimalno dozvoljeno odstupanje
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Ako je račun zamrznut , unosi dopušteno ograničene korisnike ."
DocType: Email Digest,Bank Balance,Banka Balance
apps/erpnext/erpnext/accounts/party.py +269,Accounting Entry for {0}: {1} can only be made in currency: {2},Knjiženju za {0}: {1} može se vršiti samo u valuti: {2}
DocType: HR Settings,Leave Approver Mandatory In Leave Application,Ostavite odobrenje u obaveznoj aplikaciji
DocType: Job Opening,"Job profile, qualifications required etc.","Profil posla , kvalifikacijama i sl."
DocType: Journal Entry Account,Account Balance,Bilans konta
apps/erpnext/erpnext/config/accounts.py +206,Tax Rule for transactions.,Porez pravilo za transakcije.
DocType: Rename Tool,Type of document to rename.,Vrsta dokumenta za promjenu naziva.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: gost je dužan protiv potraživanja nalog {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Ukupno Porezi i naknade (Društvo valuta)
DocType: Weather,Weather Parameter,Vremenski parametar
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +76,Show unclosed fiscal year's P&L balances,Pokaži Neriješeni fiskalnu godinu P &amp; L salda
DocType: Item,Asset Naming Series,Serija imenovanja imovine
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM.
apps/erpnext/erpnext/regional/india/utils.py +179,House rented dates should be atleast 15 days apart,Datumi koji se iznajmljuju u kući trebaju biti najmanje 15 dana
DocType: Clinical Procedure Template,Collection Details,Detalji o kolekciji
DocType: POS Profile,Allow Print Before Pay,Dozvoli štampanje pre plaćanja
DocType: Linked Soil Texture,Linked Soil Texture,Linked Soil Texture
DocType: Shipping Rule,Shipping Account,Konto transporta
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +93,{0} {1}: Account {2} is inactive,{0} {1}: Račun {2} je neaktivan
apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Make Prodajni nalozi će vam pomoći da planirate svoj rad i dostaviti na vreme
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,Bankovne transakcije
DocType: Quality Inspection,Readings,Očitavanja
DocType: Stock Entry,Total Additional Costs,Ukupno dodatnih troškova
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +47,No of Interactions,Broj interakcija
DocType: BOM,Scrap Material Cost(Company Currency),Otpadnog materijala troškova (poduzeća Valuta)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +69,Sub Assemblies,pod skupštine
DocType: Asset,Asset Name,Asset ime
DocType: Project,Task Weight,zadatak Težina
DocType: Shipping Rule Condition,To Value,Za vrijednost
DocType: Loyalty Program,Loyalty Program Type,Vrsta programa lojalnosti
DocType: Asset Movement,Stock Manager,Stock Manager
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +246,Source warehouse is mandatory for row {0},Izvor skladište je obvezno za redom {0}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Rok plaćanja na redu {0} je možda duplikat.
apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Poljoprivreda (beta)
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +916,Packing Slip,Odreskom
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Office Rent,najam ureda
apps/erpnext/erpnext/config/setup.py +105,Setup SMS gateway settings,Postavke Setup SMS gateway
DocType: Disease,Common Name,Zajedničko ime
DocType: Employee Boarding Activity,Employee Boarding Activity,Aktivnost ukrcavanja zaposlenih
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Uvoz nije uspio!
apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Još nema unijete adrese.
DocType: Workstation Working Hour,Workstation Working Hour,Workstation Radno vrijeme
DocType: Vital Signs,Blood Pressure,Krvni pritisak
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +113,Analyst,analitičar
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +20,{0} is not in a valid Payroll Period,{0} nije u važećem periodu platnog spiska
DocType: Employee Benefit Application,Max Benefits (Yearly),Maksimalne prednosti (godišnje)
DocType: Item,Inventory,Inventar
DocType: Item,Sales Details,Prodajni detalji
DocType: Opportunity,With Items,Sa stavkama
DocType: Asset Maintenance,Maintenance Team,Tim za održavanje
DocType: Salary Component,Is Additional Component,Je dodatna komponenta
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,u kol
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Potvrditi upisala kurs za studente u Studentskom Group
DocType: Notification Control,Expense Claim Rejected,Rashodi Zahtjev odbijen
DocType: Item,Item Attribute,Stavka Atributi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Government,Vlada
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Rashodi Preuzmi {0} već postoji za putnom
DocType: Asset Movement,Source Location,Izvor Lokacija
apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Institut ime
apps/erpnext/erpnext/hr/doctype/loan/loan.py +127,Please enter repayment Amount,Unesite iznos otplate
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +18,There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,Na osnovu ukupne potrošnje može biti više faktora sakupljanja. Ali faktor konverzije za otkup će uvek biti isti za sve nivoe.
apps/erpnext/erpnext/config/stock.py +312,Item Variants,Stavka Varijante
apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Usluge
DocType: Payment Order,PMO-,PMO-
DocType: HR Settings,Email Salary Slip to Employee,E-mail Plaća Slip na zaposlenog
DocType: Cost Center,Parent Cost Center,Roditelj troška
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1091,Select Possible Supplier,Odaberite Moguće dobavljač
DocType: Sales Invoice,Source,Izvor
DocType: Customer,"Select, to make the customer searchable with these fields",Izaberite da biste potrošaču omogućili pretragu sa ovim poljima
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Napomene o uvoznoj isporuci od Shopify na pošiljci
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Show zatvoren
DocType: Leave Type,Is Leave Without Pay,Ostavi se bez plate
apps/erpnext/erpnext/stock/doctype/item/item.py +276,Asset Category is mandatory for Fixed Asset item,Asset Kategorija je obavezno za Fixed stavku imovine
DocType: Fee Validity,Fee Validity,Vrijednost naknade
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146,No records found in the Payment table,Nisu pronađeni u tablici plaćanja
apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Ovo {0} sukobe sa {1} za {2} {3}
DocType: Student Attendance Tool,Students HTML,studenti HTML
DocType: POS Profile,Apply Discount,Nanesite Popust
DocType: GST HSN Code,GST HSN Code,PDV HSN Kod
DocType: Employee External Work History,Total Experience,Ukupno Iskustvo
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Open Projekti
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +297,Packing Slip(s) cancelled,Pakiranje proklizavanja ( s) otkazan
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +90,Cash Flow from Investing,Novčani tok iz ulagačkih
DocType: Program Course,Program Course,program kursa
DocType: Healthcare Service Unit,Allow Appointments,Dozvoli zakazivanja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Freight and Forwarding Charges,Teretni i Forwarding Optužbe
DocType: Homepage,Company Tagline for website homepage,Kompanija Tagline za web stranice homepage
DocType: Item Group,Item Group Name,Naziv grupe artikla
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +28,Taken,Taken
DocType: Student,Date of Leaving,Datum odlaska
DocType: Pricing Rule,For Price List,Za Cjeniku
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Executive Search
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-YYYY.-
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Podešavanje podrazumevanih vrednosti
DocType: Loyalty Program,Auto Opt In (For all customers),Automatsko uključivanje (za sve potrošače)
apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Napravi Leads
DocType: Maintenance Schedule,Schedules,Rasporedi
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +515,POS Profile is required to use Point-of-Sale,POS profil je potreban za korištenje Point-of-Sale
DocType: Cashier Closing,Net Amount,Neto iznos
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +139,{0} {1} has not been submitted so the action cannot be completed,{0} {1} nije dostavljen tako akciju nije moguće dovršiti
DocType: Purchase Order Item Supplied,BOM Detail No,BOM detalji - broj
DocType: Landed Cost Voucher,Additional Charges,dodatnih troškova
DocType: Support Search Source,Result Route Field,Polje trase rezultata
DocType: Supplier,PAN,PAN
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatni popust Iznos (Company valuta)
DocType: Supplier Scorecard,Supplier Scorecard,Scorecard dobavljača
DocType: Plant Analysis,Result Datetime,Result Datetime
,Support Hour Distribution,Podrška Distribucija sata
DocType: Maintenance Visit,Maintenance Visit,Posjeta za odrzavanje
DocType: Student,Leaving Certificate Number,Maturom Broj
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +100,"Appointment cancelled, Please review and cancel the invoice {0}","Imenovanje je otkazano, molimo pregledajte i otkažite fakturu {0}"
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Dostupno Batch Količina na Skladište
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Update Print Format
DocType: Bank Account,Is Company Account,Račun kompanije
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +58,Leave Type {0} is not encashable,Leave Type {0} nije moguće zaptivati
DocType: Landed Cost Voucher,Landed Cost Help,Sleteo Cost Pomoć
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-VLOG-.YYYY.-
DocType: Purchase Invoice,Select Shipping Address,Izaberite Dostava Adresa
DocType: Timesheet Detail,Expected Hrs,Očekivana h
apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Memebership Details
DocType: Leave Block List,Block Holidays on important days.,Blok Holidays o važnim dana.
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +194,Please input all required Result Value(s),Molimo unesite sve potrebne vrijednosti rezultata (i)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +119,Accounts Receivable Summary,Potraživanja Pregled
DocType: POS Closing Voucher,Linked Invoices,Povezane fakture
DocType: Loan,Monthly Repayment Amount,Mjesečna otplate Iznos
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Otvaranje faktura
DocType: Contract,Contract Details,Detalji ugovora
DocType: Employee,Leave Details,Ostavite detalje
apps/erpnext/erpnext/hr/doctype/employee/employee.py +211,Please set User ID field in an Employee record to set Employee Role,Molimo postavite korisniku ID polja u rekord zaposlenog da postavite uloga zaposlenih
DocType: UOM,UOM Name,UOM Ime
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +237,To Address 1,Za adresu 1
DocType: GST HSN Code,HSN Code,HSN Kod
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py +87,Contribution Amount,Doprinos Iznos
DocType: Inpatient Record,Patient Encounter,Patient Encounter
DocType: Purchase Invoice,Shipping Address,Adresa isporuke
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.,Ovaj alat pomaže vam da ažurirate ili popraviti količinu i vrednovanje zaliha u sistemu. To se obično koristi za usklađivanje vrijednosti sistema i ono što zaista postoji u skladištima.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,Riječima će biti vidljivo nakon što spremite otpremnicu.
apps/erpnext/erpnext/erpnext_integrations/utils.py +22,Unverified Webhook Data,Neprevereni podaci Webhook-a
DocType: Water Analysis,Container,Kontejner
apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} pojavljuje više puta u nizu {2} i {3}
DocType: Item Alternative,Two-way,Dvosmerno
DocType: Project,Day to Send,Dan za slanje
DocType: Healthcare Settings,Manage Sample Collection,Upravljanje sakupljanjem uzorka
DocType: Production Plan,Ignore Existing Ordered Quantity,Ignorišite postojeću porudžbenu količinu
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +73,Please set the series to be used.,Molimo postavite seriju koja će se koristiti.
DocType: Patient,Tobacco Past Use,Korišćenje prošlosti duvana
DocType: Travel Itinerary,Mode of Travel,Režim putovanja
DocType: Sales Invoice Item,Brand Name,Naziv brenda
DocType: Purchase Receipt,Transporter Details,Transporter Detalji
apps/erpnext/erpnext/accounts/page/pos/pos.js +2711,Default warehouse is required for selected item,Uobičajeno skladište je potreban za izabranu stavku
apps/erpnext/erpnext/utilities/user_progress.py +146,Box,Kutija
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1088,Possible Supplier,moguće dobavljač
DocType: Budget,Monthly Distribution,Mjesečni Distribucija
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Receiver Lista je prazna . Molimo stvoriti Receiver Popis
apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Zdravstvo (beta)
DocType: Production Plan Sales Order,Production Plan Sales Order,Proizvodnja plan prodajnog naloga
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +419,"No active BOM found for item {0}. Delivery by \
						Serial No cannot be ensured",Nije pronađena aktivna BOM za stavku {0}. Ne može se osigurati isporuka sa \ Serial No.
DocType: Sales Partner,Sales Partner Target,Prodaja partner Target
DocType: Loan Type,Maximum Loan Amount,Maksimalni iznos kredita
DocType: Pricing Rule,Pricing Rule,cijene Pravilo
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Duplikat broj roll za studentske {0}
apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Materijal Zahtjev za narudžbenice
DocType: Shopping Cart Settings,Payment Success URL,Plaćanje Uspjeh URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +79,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: {1} Returned Stavka ne postoji u {2} {3}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankovni računi
,Bank Reconciliation Statement,Izjava banka pomirenja
DocType: Patient Encounter,Medical Coding,Medicinsko kodiranje
DocType: Healthcare Settings,Reminder Message,Poruka podsetnika
,Lead Name,Ime Lead-a
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +314,Prospecting,Istraživanje
apps/erpnext/erpnext/config/stock.py +317,Opening Stock Balance,Otvaranje Stock Balance
DocType: Asset Category Account,Capital Work In Progress Account,Kapitalni rad je u toku
apps/erpnext/erpnext/assets/doctype/asset/asset.js +92,Asset Value Adjustment,Podešavanje vrednosti imovine
DocType: Additional Salary,Payroll Date,Datum plaćanja
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} se mora pojaviti samo jednom
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Lišće Dodijeljeni uspješno za {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Nema stavki za omot
DocType: Shipping Rule Condition,From Value,Od Vrijednost
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +713,Manufacturing Quantity is mandatory,Proizvodnja Količina je obvezno
DocType: Loan,Repayment Method,otplata Način
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Ako je označeno, na početnu stranicu će biti default Stavka grupe za web stranicu"
DocType: Quality Inspection Reading,Reading 4,Čitanje 4
apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Studenti su u srcu sistema, dodajte sve svoje studente"
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +16,Member ID,Član ID
DocType: Employee Tax Exemption Proof Submission,Monthly Eligible Amount,Mesečni iznos kvalifikovanog iznosa
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: datum razmak {1} ne može biti prije Ček Datum {2}
DocType: Asset Maintenance Task,Certificate Required,Sertifikat je potreban
DocType: Company,Default Holiday List,Uobičajeno Holiday List
DocType: Pricing Rule,Supplier Group,Grupa dobavljača
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +61,{0} Digest,{0} Digest
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +151,Row {0}: From Time and To Time of {1} is overlapping with {2},Red {0}: Od vremena i do vremena od {1} je preklapaju s {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Stock Liabilities,Stock Obveze
DocType: Purchase Invoice,Supplier Warehouse,Dobavljač galerija
DocType: Opportunity,Contact Mobile No,Kontak GSM
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +53,Select Company,Izaberite kompaniju
,Material Requests for which Supplier Quotations are not created,Materijalni Zahtjevi za koje Supplier Citati nisu stvorene
DocType: Student Report Generation Tool,Print Section,Odsek za štampu
DocType: Staffing Plan Detail,Estimated Cost Per Position,Procijenjeni trošak po poziciji
DocType: Employee,HR-EMP-,HR-EMP-
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.,Korisnik {0} nema podrazumevani POS profil. Provjerite Podrazumevano na Rowu {1} za ovog Korisnika.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Employee Referral,Upućivanje zaposlenih
DocType: Student Group,Set 0 for no limit,Set 0 za no limit
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +191,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Dan (e) na koje se prijavljujete za odmor su praznici. Vi ne trebate podnijeti zahtjev za dozvolu.
DocType: Customer,Primary Address and Contact Detail,Primarna adresa i kontakt detalji
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +21,Resend Payment Email,Ponovo pošaljite mail plaćanja
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,novi zadatak
DocType: Clinical Procedure,Appointment,Imenovanje
apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Make ponudu
apps/erpnext/erpnext/config/education.py +230,Other Reports,Ostali izveštaji
apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Izaberite najmanje jedan domen.
DocType: Dependent Task,Dependent Task,Zavisna Task
DocType: Shopify Settings,Shopify Tax Account,Kupujte poreski račun
apps/erpnext/erpnext/stock/doctype/item/item.py +461,Conversion factor for default Unit of Measure must be 1 in row {0},Faktor pretvorbe za zadani jedinica mjere mora biti jedan u nizu {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +258,Leave of type {0} cannot be longer than {1},Ostavite tipa {0} ne može biti duži od {1}
DocType: Delivery Trip,Optimize Route,Optimizirajte rutu
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Pokušajte planiraju operacije za X dana unaprijed.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +90,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.",{0} slobodna radna mjesta i {1} budžet za {2} već planiran za podružnice preduzeća {3}. \ Možete planirati samo do {4} slobodnih radnih mesta i budžeta {5} po planu osoblja {6} za matičnu kompaniju {3}.
DocType: HR Settings,Stop Birthday Reminders,Zaustavi Rođendan Podsjetnici
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +203,Please set Default Payroll Payable Account in Company {0},Molimo podesite Uobičajeno plaće plaćaju račun poduzeća {0}
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,Dobije finansijski raspad podataka o porezima i naplaćuje Amazon
DocType: SMS Center,Receiver List,Lista primalaca
apps/erpnext/erpnext/accounts/page/pos/pos.js +1108,Search Item,Traži Stavka
DocType: Payment Schedule,Payment Amount,Plaćanje Iznos
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +20,Half Day Date should be in between Work From Date and Work End Date,Datum poluvremena treba da bude između rada od datuma i datuma rada
DocType: Healthcare Settings,Healthcare Service Items,Stavke zdravstvene zaštite
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Consumed Amount,Consumed Iznos
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +69,Net Change in Cash,Neto promjena u gotovini
DocType: Assessment Plan,Grading Scale,Pravilo Scale
apps/erpnext/erpnext/stock/doctype/item/item.py +455,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Jedinica mjere {0} je ušao više od jednom u konverzije Factor tablici
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +617,Already completed,već završena
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +34,Stock In Hand,Stock u ruci
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +68,"Please add the remaining benefits {0} to the application as \
				pro-rata component",Molimo dodajte preostale pogodnosti {0} aplikaciji kao \ pro-rata komponentu
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Uvoz uspješan!
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +35,Payment Request already exists {0},Plaćanje Zahtjev već postoji {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Troškovi Izdata Predmeti
DocType: Healthcare Practitioner,Hospital,Bolnica
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +534,Quantity must not be more than {0},Količina ne smije biti više od {0}
DocType: Travel Request Costing,Funded Amount,Sredstveni iznos
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +120,Previous Financial Year is not closed,Prethodne finansijske godine nije zatvoren
DocType: Practitioner Schedule,Practitioner Schedule,Raspored lekara
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +69,Age (Days),Starost (dani)
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Additional Salary,Additional Salary,Dodatna plata
DocType: Quotation Item,Quotation Item,Artikl iz ponude
DocType: Customer,Customer POS Id,Kupac POS Id
DocType: Account,Account Name,Naziv konta
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +496,From Date cannot be greater than To Date,Od datuma ne može biti veća od To Date
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +203,Serial No {0} quantity {1} cannot be a fraction,Serijski Ne {0} {1} količina ne može bitidio
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +96,Please enter Woocommerce Server URL,Molimo unesite URL adresu Woocommerce Servera
DocType: Purchase Order Item,Supplier Part Number,Dobavljač Broj dijela
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +136,Conversion rate cannot be 0 or 1,Stopa pretvorbe ne može biti 0 ili 1
DocType: Share Balance,To No,Da ne
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +27,All the mandatory Task for employee creation hasn't been done yet.,Sva obavezna zadatka za stvaranje zaposlenih još nije izvršena.
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +227,{0} {1} is cancelled or stopped,{0} {1} je otkazan ili zaustavljen
DocType: Accounts Settings,Credit Controller,Kreditne kontroler
DocType: Loan,Applicant Type,Tip podnosioca zahteva
DocType: Purchase Invoice,03-Deficiency in services,03-Nedostatak usluga
DocType: Healthcare Settings,Default Medical Code Standard,Standardni medicinski kodni standard
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +265,Purchase Receipt {0} is not submitted,Račun kupnje {0} nije podnesen
DocType: Company,Default Payable Account,Uobičajeno računa se plaća
apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Postavke za online kupovinu košaricu poput shipping pravila, cjenik i sl"
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-YYYY.-
apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% Fakturisana
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Rezervirano Kol
DocType: Party Account,Party Account,Party račun
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +142,Please select Company and Designation,Izaberite kompaniju i oznaku
apps/erpnext/erpnext/config/setup.py +116,Human Resources,Ljudski resursi
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +306,Upper Income,Viši Prihodi
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,odbiti
DocType: Journal Entry Account,Debit in Company Currency,Debit u Company valuta
DocType: BOM Item,BOM Item,BOM proizvod
DocType: Appraisal,For Employee,Za zaposlenom
DocType: Vital Signs,Full,Pun
apps/erpnext/erpnext/hr/doctype/loan/loan.js +69,Make Disbursement Entry,Make isplata Entry
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +170,Row {0}: Advance against Supplier must be debit,Red {0}: Advance protiv Dobavljač mora biti debitne
DocType: Company,Default Values,Default vrijednosti
DocType: Certification Application,INR,INR
DocType: Expense Claim,Total Amount Reimbursed,Ukupan iznos nadoknađeni
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Ovo se zasniva na rezanje protiv ovog vozila. Pogledajte vremenski okvir ispod za detalje
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py +21,Payroll date can not be less than employee's joining date,Datum plaćanja ne može biti manji od datuma pridruživanja zaposlenog
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py +87,{0} {1} created,{0} {1} stvorio
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +46,"Job Openings for designation {0} already open \
					or hiring completed as per Staffing Plan {1}",Otvaranje radnih mjesta za imenovanje {0} već otvoreno ili zapošljavanje završeno u skladu sa planom osoblja {1}
DocType: Vital Signs,Constipated,Zapremljen
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Against Supplier Invoice {0} dated {1},Protiv Dobavljač fakture {0} od {1}
DocType: Customer,Default Price List,Zadani cjenik
apps/erpnext/erpnext/assets/doctype/asset/asset.py +483,Asset Movement record {0} created,rekord Asset pokret {0} stvorio
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +175,No items found.,Ništa nije pronađeno.
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,Ne možete izbrisati fiskalnu godinu {0}. Fiskalna godina {0} je postavljen kao zadani u Globalne postavke
DocType: Share Transfer,Equity/Liability Account,Račun kapitala / obaveza
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Kupac sa istim imenom već postoji
DocType: Contract,Inactive,Neaktivan
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +224,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Ovo će poslati naknade za plate i kreirati obračunski dnevnik. Da li želite da nastavite?
DocType: Purchase Invoice,Total Net Weight,Ukupna neto težina
DocType: Purchase Order,Order Confirmation No,Potvrda o porudžbini br
DocType: Purchase Invoice,Eligibility For ITC,Prikladnost za ITC
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-YYYY.-
DocType: Journal Entry,Entry Type,Entry Tip
,Customer Credit Balance,Customer Credit Balance
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +82,Net Change in Accounts Payable,Neto promjena na računima dobavljača
apps/erpnext/erpnext/selling/doctype/customer/customer.py +257,Credit limit has been crossed for customer {0} ({1}/{2}),Kreditni limit je prešao za kupca {0} ({1} / {2})
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Kupac je potrebno za ' Customerwise Popust '
apps/erpnext/erpnext/config/accounts.py +163,Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +26,Pricing,cijene
DocType: Quotation,Term Details,Oročeni Detalji
DocType: Employee Incentive,Employee Incentive,Incentive za zaposlene
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Ne može upisati više od {0} studenata za ovu grupa studenata.
apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),Ukupno (bez poreza)
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Lead Count
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Stock Available,Stock Available
DocType: Manufacturing Settings,Capacity Planning For (Days),Kapacitet planiranje (Dana)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,nabavka
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +67,None of the items have any change in quantity or value.,Nijedan od stavki imaju bilo kakve promjene u količini ili vrijednosti.
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +22,Mandatory field - Program,Obavezna polja - Program
DocType: Special Test Template,Result Component,Komponenta rezultata
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Garantni  rok
,Lead Details,Detalji potenciajalnog kupca
DocType: Volunteer,Availability and Skills,Dostupnost i vještine
DocType: Salary Slip,Loan repayment,otplata kredita
DocType: Share Transfer,Asset Account,Račun imovine
DocType: Purchase Invoice,End date of current invoice's period,Kraj datum tekućeg razdoblja dostavnice
DocType: Pricing Rule,Applicable For,primjenjivo za
DocType: Lab Test,Technician Name,Ime tehničara
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +411,"Cannot ensure delivery by Serial No as \
					Item {0} is added with and without Ensure Delivery by \
					Serial No.",Ne može se osigurati isporuka pomoću serijskog broja dok se \ Item {0} dodaje sa i bez Osiguranje isporuke od \ Serijski broj
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Odvajanje Plaćanje o otkazivanju fakture
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Trenutno čitanje Odometar ušli bi trebao biti veći od početnog kilometraže vozila {0}
DocType: Restaurant Reservation,No Show,Ne Show
DocType: Shipping Rule Country,Shipping Rule Country,Dostava Pravilo Country
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Ostavite i posjećenost
DocType: Asset,Comprehensive Insurance,Sveobuhvatno osiguranje
DocType: Maintenance Visit,Partially Completed,Djelomično Završeni
apps/erpnext/erpnext/selling/doctype/customer/customer.js +118,Loyalty Point: {0},Tačka lojalnosti: {0}
apps/erpnext/erpnext/public/js/event.js +15,Add Leads,Add Leads
apps/erpnext/erpnext/healthcare/setup.py +189,Moderate Sensitivity,Umerena osetljivost
DocType: Leave Type,Include holidays within leaves as leaves,Uključiti praznika u roku od lišća što je lišće
DocType: Loyalty Program,Redemption,Otkupljenje
DocType: Sales Invoice,Packed Items,Pakirano Predmeti
DocType: Tax Withholding Category,Tax Withholding Rates,Poreske stope odbijanja
DocType: Contract,Contract Period,Period ugovora
apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Garantni rok protiv Serial No.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215,'Total',&#39;Ukupno&#39;
DocType: Employee,Permanent Address,Stalna adresa
DocType: Loyalty Program,Collection Tier,Kolekcija Tier
apps/erpnext/erpnext/hr/utils.py +156,From date can not be less than employee's joining date,Od datuma ne može biti manje od datuma pridruživanja zaposlenog
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Unaprijed plaćeni protiv {0} {1} ne može biti veći \ od Grand Ukupno {2}
DocType: Patient,Medication,Lijekovi
DocType: Production Plan,Include Non Stock Items,Uključite stavke bez zaliha
DocType: Project Update,Challenging/Slow,Izazivanje / sporo
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Odaberite Šifra
DocType: Student Sibling,Studying in Same Institute,Studiranje u istom institutu
DocType: Leave Type,Earned Leave,Zarađeni odlazak
DocType: Employee,Salary Details,Plate Detalji
DocType: Territory,Territory Manager,Manager teritorije
DocType: Packed Item,To Warehouse (Optional),Da Warehouse (Opcionalno)
DocType: GST Settings,GST Accounts,GST računi
DocType: Payment Entry,Paid Amount (Company Currency),Uplaćeni iznos (poduzeća Valuta)
DocType: Purchase Invoice,Additional Discount,Dodatni popust
DocType: Selling Settings,Selling Settings,Podešavanja prodaje
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Online aukcije
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +101,Please specify either Quantity or Valuation Rate or both,Navedite ili količini ili vrednovanja Ocijenite ili oboje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,ispunjenje
apps/erpnext/erpnext/templates/generators/item.html +101,View in Cart,Pogledaj u košaricu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Marketing Expenses,Troškovi marketinga
,Item Shortage Report,Nedostatak izvješća za artikal
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Ne mogu napraviti standardne kriterijume. Molim preimenovati kriterijume
apps/erpnext/erpnext/stock/doctype/item/item.js +360,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Težina se spominje, \n Navedite ""Težina UOM"" previše"
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materijal Zahtjev se koristi da bi se ova Stock unos
DocType: Hub User,Hub Password,Hub Password
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Poseban grupe na osnovu naravno za svaku seriju
apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Jedna jedinica stavku.
DocType: Fee Category,Fee Category,naknada Kategorija
DocType: Agriculture Task,Next Business Day,Sledeći radni dan
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +3,Allocated Leaves,Dodijeljene liste
DocType: Drug Prescription,Dosage by time interval,Doziranje po vremenskom intervalu
DocType: Cash Flow Mapper,Section Header,Header odeljka
,Student Fee Collection,Student Naknada Collection
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +24,Appointment Duration (mins),Trajanje imenovanja (min)
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Provjerite knjiženje za svaki burzi pokreta
DocType: Leave Allocation,Total Leaves Allocated,Ukupno Lišće Dodijeljeni
apps/erpnext/erpnext/public/js/setup_wizard.js +178,Please enter valid Financial Year Start and End Dates,Molimo vas da unesete važeću finansijsku godinu datume početka i završetka
DocType: Employee,Date Of Retirement,Datum odlaska u mirovinu
DocType: Upload Attendance,Get Template,Kreiraj predložak
,Sales Person Commission Summary,Povjerenik Komisije za prodaju
DocType: Additional Salary Component,Additional Salary Component,Dodatna plata komponenta
DocType: Material Request,Transferred,prebačen
DocType: Vehicle,Doors,vrata
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +118,ERPNext Setup Complete!,ERPNext Setup Complete!
DocType: Healthcare Settings,Collect Fee for Patient Registration,Prikupiti naknadu za registraciju pacijenta
apps/erpnext/erpnext/stock/doctype/item/item.py +717,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Ne mogu promijeniti atribute nakon transakcije sa akcijama. Napravite novu stavku i prenesite zalihu na novu stavku
DocType: Course Assessment Criteria,Weightage,Weightage
DocType: Purchase Invoice,Tax Breakup,porez Raspad
DocType: Employee,Joining Details,Sastavljanje Detalji
DocType: Member,Non Profit Member,Član neprofitne organizacije
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}: Troškovi Centar je potreban za &quot;dobiti i gubitka računa {2}. Molimo vas da se uspostavi default troškova Centra za kompanije.
DocType: Payment Schedule,Payment Term,Rok plaćanja
apps/erpnext/erpnext/selling/doctype/customer/customer.py +175,A Customer Group exists with same name please change the Customer name or rename the Customer Group,Grupa kupaca sa istim nazivom već postoji. Promijenite naziv kupca ili promijenite naziv grupe kupaca.
DocType: Location,Area,Područje
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Novi kontakt
DocType: Company,Company Description,Opis preduzeća
DocType: Territory,Parent Territory,Roditelj Regija
DocType: Purchase Invoice,Place of Supply,Mesto isporuke
DocType: Quality Inspection Reading,Reading 2,Čitanje 2
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +101,Employee {0} already submited an apllication {1} for the payroll period {2},Zaposleni {0} već je podneo primenu {1} za period platnog spiska {2}
DocType: Stock Entry,Material Receipt,Materijal Potvrda
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,Pošalji / usaglasite plaćanja
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-YYYY.-
DocType: Homepage,Products,Proizvodi
DocType: Announcement,Instructor,instruktor
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +95,Select Item (optional),Izaberite stavku (opcionalno)
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +103,The Loyalty Program isn't valid for the selected company,Program lojalnosti ne važi za izabranu kompaniju
DocType: Fee Schedule Student Group,Fee Schedule Student Group,Raspored studijske grupe
DocType: Student,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ako ova stavka ima varijante, onda ne može biti izabran u prodaji naloge itd"
DocType: Lead,Next Contact By,Sledeci put kontaktirace ga
DocType: Compensatory Leave Request,Compensatory Leave Request,Kompenzacijski zahtev za odlazak
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +334,Quantity required for Item {0} in row {1},Količina potrebna za točke {0} je u redu {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45,Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti izbrisano ako na njemu ima artikal {1}
DocType: Blanket Order,Order Type,Vrsta narudžbe
,Item-wise Sales Register,Stavka-mudri prodaja registar
DocType: Asset,Gross Purchase Amount,Bruto Kupovina Iznos
apps/erpnext/erpnext/utilities/user_progress.py +39,Opening Balances,Početni balansi
DocType: Asset,Depreciation Method,Način Amortizacija
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je li ovo pristojba uključena u osnovne stope?
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Target,Ukupna ciljna
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +319,Perception Analysis,Analiza percepcije
DocType: Soil Texture,Sand Composition (%),Kompozicija peska (%)
DocType: Job Applicant,Applicant for a Job,Kandidat za posao
DocType: Production Plan Material Request,Production Plan Material Request,Proizvodni plan materijala Upit
DocType: Purchase Invoice,Release Date,Datum izdavanja
DocType: Stock Reconciliation,Reconciliation JSON,Pomirenje JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +5,Too many columns. Export the report and print it using a spreadsheet application.,Previše stupovi. Izvesti izvješće i ispisati pomoću aplikacije za proračunske tablice.
DocType: Purchase Invoice Item,Batch No,Broj serije
DocType: Marketplace Settings,Hub Seller Name,Hub Ime prodavca
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +27,Employee Advances,Napredak zaposlenih
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Dopustite više prodajnih naloga protiv narudžbenicu Kupca
DocType: Student Group Instructor,Student Group Instructor,Student Group Instruktor
DocType: Grant Application,Assessment  Mark (Out of 10),Oznaka ocene (od 10)
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile Nema
apps/erpnext/erpnext/setup/doctype/company/company.py +263,Main,Glavni
apps/erpnext/erpnext/controllers/buying_controller.py +762,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Sledeća stavka {0} nije označena kao {1} stavka. Možete ih omogućiti kao {1} stavku iz glavnog poglavlja
apps/erpnext/erpnext/stock/doctype/item/item.js +74,Variant,Varijanta
apps/erpnext/erpnext/controllers/status_updater.py +163,"For an item {0}, quantity must be negative number","Za stavku {0}, količina mora biti negativna"
DocType: Naming Series,Set prefix for numbering series on your transactions,Postavite prefiks za numeriranje niza na svoje transakcije
DocType: Employee Attendance Tool,Employees HTML,Zaposleni HTML
apps/erpnext/erpnext/stock/doctype/item/item.py +475,Default BOM ({0}) must be active for this item or its template,Uobičajeno BOM ({0}) mora biti aktivna za ovu stavku ili njegove predložak
DocType: Employee,Leave Encashed?,Ostavite Encashed?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Prilika iz polja je obavezna
DocType: Email Digest,Annual Expenses,Godišnji troškovi
DocType: Item,Variants,Varijante
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1226,Make Purchase Order,Provjerite narudžbenice
DocType: SMS Center,Send To,Pošalji na adresu
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +202,There is not enough leave balance for Leave Type {0},Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
DocType: Payment Reconciliation Payment,Allocated amount,Izdvojena iznosu
DocType: Sales Team,Contribution to Net Total,Doprinos neto Ukupno
DocType: Sales Invoice Item,Customer's Item Code,Kupca Stavka Šifra
DocType: Stock Reconciliation,Stock Reconciliation,Kataloški pomirenje
DocType: Territory,Territory Name,Regija Ime
DocType: Email Digest,Purchase Orders to Receive,Narudžbe za kupovinu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +197,Work-in-Progress Warehouse is required before Submit,Rad u tijeku Warehouse je potrebno prije Podnijeti
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +71,You can only have Plans with the same billing cycle in a Subscription,Planove možete imati samo sa istim ciklusom naplate na Pretplati
DocType: Bank Statement Transaction Settings Item,Mapped Data,Mapped Data
DocType: Purchase Order Item,Warehouse and Reference,Skladište i upute
DocType: Payroll Period Date,Payroll Period Date,Datum perioda plaćanja
DocType: Supplier,Statutory info and other general information about your Supplier,Zakonska info i druge opće informacije o vašem Dobavljaču
DocType: Item,Serial Nos and Batches,Serijski brojevi i Paketi
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Student Group Strength
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +262,Against Journal Entry {0} does not have any unmatched {1} entry,Protiv Journal Entry {0} nema premca {1} unos
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +113,"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
				Staffing Plan for {0} should allocate more vacancies and budget for {3} than planned for its subsidiary companies",Pomoćne kompanije su već planirale za {1} slobodna radna mesta u budžetu od {2}. \ Plan kadrova za {0} treba izdvojiti više radnih mjesta i budžet za {3} od planiranog za svoje supsidijarne kompanije
apps/erpnext/erpnext/config/hr.py +166,Appraisals,Appraisals
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Događaji obuke
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +210,Duplicate Serial No entered for Item {0},Dupli serijski broj je unešen za artikl {0}
apps/erpnext/erpnext/config/selling.py +179,Track Leads by Lead Source.,Vodite praćenje po izvorima izvora.
DocType: Shipping Rule Condition,A condition for a Shipping Rule,A uvjet za Shipping Pravilo
apps/erpnext/erpnext/hr/doctype/employee/employee.py +175,Please enter ,Molimo unesite
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +64,Maintenance Log,Dnevnik održavanja
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +242,Please set filter based on Item or Warehouse,Molimo podesite filter na osnovu Item ili Skladište
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Neto težina tog paketa. (Automatski izračunava kao zbroj neto težini predmeta)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +43,Make Inter Company Journal Entry,Napravite Inter Company Journal Entry
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +901,Discount amount cannot be greater than 100%,Iznos popusta ne može biti veći od 100%
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-YYYY.-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +26,"Number of new Cost Center, it will be included in the cost center name as a prefix",Broj novih troškovnih centara će biti uključen u naziv troškovnog centra kao prefiks
DocType: Sales Order,To Deliver and Bill,Dostaviti i Bill
DocType: Student Group,Instructors,instruktori
DocType: GL Entry,Credit Amount in Account Currency,Iznos kredita u računu valuta
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +625,BOM {0} must be submitted,BOM {0} mora biti dostavljena
apps/erpnext/erpnext/config/accounts.py +504,Share Management,Share Management
DocType: Authorization Control,Authorization Control,Odobrenje kontrole
apps/erpnext/erpnext/controllers/buying_controller.py +404,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Odbijena Skladište je obavezno protiv odbijen Stavka {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +880,Payment,Plaćanje
apps/erpnext/erpnext/controllers/stock_controller.py +96,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Skladište {0} nije povezan na bilo koji račun, navedite račun u zapisnik skladištu ili postaviti zadani popis računa u firmi {1}."
apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Upravljanje narudžbe
DocType: Work Order Operation,Actual Time and Cost,Stvarno vrijeme i troškovi
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +57,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materijal Zahtjev maksimalno {0} može biti za točku {1} od prodajnog naloga {2}
DocType: Amazon MWS Settings,DE,DE
DocType: Crop,Crop Spacing,Rastojanje usjeva
DocType: Course,Course Abbreviation,Skraćenica za golf
DocType: Budget,Action if Annual Budget Exceeded on PO,Akcija ako je godišnji budžet prešao na PO
DocType: Student Leave Application,Student Leave Application,Student Leave aplikacije
DocType: Item,Will also apply for variants,Primjenjivat će se i za varijante
apps/erpnext/erpnext/assets/doctype/asset/asset.py +288,"Asset cannot be cancelled, as it is already {0}","Imovine ne može biti otkazan, jer je već {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +31,Employee {0} on Half day on {1},Zaposlenik {0} na Poludnevni na {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +59,Total working hours should not be greater than max working hours {0},Ukupno radnog vremena ne smije biti veća od max radnog vremena {0}
apps/erpnext/erpnext/templates/pages/task_info.html +90,On,na
apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Bala stavke na vrijeme prodaje.
DocType: Delivery Settings,Dispatch Settings,Dispečerske postavke
DocType: Material Request Plan Item,Actual Qty,Stvarna kol
DocType: Sales Invoice Item,References,Reference
DocType: Quality Inspection Reading,Reading 10,Čitanje 10
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +48,Serial nos {0} does not belongs to the location {1},Serijski nos {0} ne pripada lokaciji {1}
DocType: Item,Barcodes,Barkodovi
DocType: Hub Tracked Item,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.,Unijeli duple stavke . Molimo ispraviti i pokušajte ponovno .
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Associate,Pomoćnik
DocType: Asset Movement,Asset Movement,Asset pokret
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +601,Work Order {0} must be submitted,Radni nalog {0} mora biti dostavljen
apps/erpnext/erpnext/accounts/page/pos/pos.js +2225,New Cart,novi Košarica
DocType: Taxable Salary Slab,From Amount,Od iznosa
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Stavka {0} nijeserijaliziranom predmeta
DocType: Leave Type,Encashment,Encashment
DocType: Delivery Settings,Delivery Settings,Postavke isporuke
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py +16,Maximum leave allowed in the leave type {0} is {1},Maksimalni dozvoljeni odmor u tipu odlaska {0} je {1}
DocType: SMS Center,Create Receiver List,Kreiraj listu primalaca
DocType: Vehicle,Wheels,Wheels
DocType: Packing Slip,To Package No.,Za Paket br
DocType: Patient Relation,Family,Porodica
DocType: Sales Invoice Item,Deferred Revenue Account,Odgođeni račun za prihode
DocType: Production Plan,Material Requests,materijal Zahtjevi
DocType: Warranty Claim,Issue Date,Datum izdavanja
DocType: Activity Cost,Activity Cost,Aktivnost troškova
DocType: Sales Invoice Timesheet,Timesheet Detail,Timesheet Detail
DocType: Purchase Receipt Item Supplied,Consumed Qty,Potrošeno Kol
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekomunikacije
apps/erpnext/erpnext/accounts/party.py +292,Billing currency must be equal to either default company's currency or party account currency,Valuta za obračun mora biti jednaka valuti valute kompanije ili valute partijskog računa
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Ukazuje da je paket je dio ove isporuke (samo nacrti)
DocType: Soil Texture,Loam,Loam
apps/erpnext/erpnext/controllers/accounts_controller.py +770,Row {0}: Due Date cannot be before posting date,Red {0}: Due Date ne može biti pre datuma objavljivanja
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +37,Make Payment Entry,Napravite unos Plaćanje
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Količina za točku {0} mora biti manji od {1}
,Sales Invoice Trends,Trendovi prodajnih računa
DocType: Leave Application,Apply / Approve Leaves,Nanesite / Odobri Leaves
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +180,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Može se odnositi red samo akotip zadužen je "" Na prethodni red Iznos 'ili' prethodnog retka Total '"
DocType: Sales Order Item,Delivery Warehouse,Isporuka Skladište
DocType: Leave Type,Earned Leave Frequency,Zarađena frekvencija odlaska
apps/erpnext/erpnext/config/accounts.py +279,Tree of financial Cost Centers.,Tree financijskih troškova centara.
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +151,Sub Type,Pod Tip
DocType: Serial No,Delivery Document No,Dokument isporuke br
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Osigurati isporuku zasnovanu na serijskom br
DocType: Vital Signs,Furry,Furry
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +197,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Molimo podesite &#39;dobitak / gubitak računa na Asset Odlaganje&#39; u kompaniji {0}
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Get Predmeti iz otkupa Primici
DocType: Serial No,Creation Date,Datum stvaranja
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +55,Target Location is required for the asset {0},Ciljna lokacija je potrebna za sredstvo {0}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +42,"Selling must be checked, if Applicable For is selected as {0}","Prodaje se mora provjeriti, ako je primjenjivo za odabrano kao {0}"
DocType: Production Plan Material Request,Material Request Date,Materijal Upit Datum
DocType: Purchase Order Item,Supplier Quotation Item,Dobavljač ponudu artikla
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +205,Material Consumption is not set in Manufacturing Settings.,Potrošnja materijala nije podešena u proizvodnim postavkama.
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-YYYY.-
apps/erpnext/erpnext/templates/pages/help.html +46,Visit the forums,Posjetite forum
DocType: Student,Student Mobile Number,Student Broj mobilnog
DocType: Item,Has Variants,Ima Varijante
DocType: Employee Benefit Claim,Claim Benefit For,Claim Benefit For
apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Update Response
apps/erpnext/erpnext/public/js/utils.js +512,You have already selected items from {0} {1},Vi ste već odabrane stavke iz {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Naziv Mjesečni distribucije
apps/erpnext/erpnext/stock/doctype/batch/batch.py +100,Batch ID is mandatory,Batch ID je obavezno
DocType: Sales Person,Parent Sales Person,Roditelj Prodaja Osoba
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +102,No items to be received are overdue,Nijedna stavka koja se primi ne kasni
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +101,The seller and the buyer cannot be the same,Prodavac i kupac ne mogu biti isti
DocType: Project,Collect Progress,Prikupi napredak
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-YYYY.-
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Prvo izaberite program
DocType: Patient Appointment,Patient Age,Pacijentsko doba
apps/erpnext/erpnext/config/learn.py +253,Managing Projects,Upravljanje projektima
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +229,Serial no {0} has been already returned,Serijski broj {0} je već vraćen
DocType: Supplier,Supplier of Goods or Services.,Dobavljač robe ili usluga.
DocType: Budget,Fiscal Year,Fiskalna godina
DocType: Asset Maintenance Log,Planned,Planirano
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +89,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Molimo da podesite serije brojeva za prisustvo preko Setup&gt; Serija numeracije
apps/erpnext/erpnext/hr/utils.py +198,A {0} exists between {1} and {2} (,A {0} postoji između {1} i {2} (
DocType: Vehicle Log,Fuel Price,Cena goriva
DocType: Bank Guarantee,Margin Money,Margin Money
DocType: Budget,Budget,Budžet
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +79,Set Open,Set Open
apps/erpnext/erpnext/stock/doctype/item/item.py +273,Fixed Asset Item must be a non-stock item.,Osnovnih sredstava Stavka mora biti ne-stock stavku.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +60,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budžet se ne može dodijeliti protiv {0}, jer to nije prihod ili rashod račun"
apps/erpnext/erpnext/hr/utils.py +227,Max exemption amount for {0} is {1},Maksimalna izuzeća za {0} je {1}
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Ostvareni
DocType: Student Admission,Application Form Route,Obrazac za prijavu Route
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Teritorij / Customer
DocType: Healthcare Settings,Patient Encounters in valid days,Pacijent susreta u važećim danima
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +58,Leave Type {0} cannot be allocated since it is leave without pay,Ostavite Tip {0} ne može se dodijeliti jer se ostavi bez plate
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: {1} Izdvojena iznos mora biti manji od ili jednak naplatiti preostali iznos {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,U riječi će biti vidljiv nakon što spremite prodaje fakture.
DocType: Lead,Follow Up,Pratite gore
DocType: Item,Is Sales Item,Je artikl namijenjen prodaji
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +55,Item Group Tree,Raspodjela grupe artikala
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +73,Item {0} is not setup for Serial Nos. Check Item master,"Stavka {0} nije dobro postavljen za gospodara , serijski brojevi Provjera"
DocType: Maintenance Visit,Maintenance Time,Održavanje Vrijeme
,Amount to Deliver,Iznose Deliver
DocType: Asset,Insurance Start Date,Datum početka osiguranja
DocType: Salary Component,Flexible Benefits,Fleksibilne prednosti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +345,Same item has been entered multiple times. {0},Ista stavka je uneta više puta. {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.,Termin Ozljede Datum ne može biti ranije od godine Početak Datum akademske godine za koji je vezana pojam (akademska godina {}). Molimo ispravite datume i pokušajte ponovo.
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +201,There were errors.,Bilo je grešaka .
apps/erpnext/erpnext/hr/doctype/shift_request/shift_request.py +68,Employee {0} has already applied for {1} between {2} and {3} : ,Zaposleni {0} već je prijavio za {1} između {2} i {3}:
DocType: Guardian,Guardian Interests,Guardian Interesi
apps/erpnext/erpnext/accounts/doctype/account/account.js +45,Update Account Name / Number,Ažurirajte ime / broj računa
DocType: Naming Series,Current Value,Trenutna vrijednost
apps/erpnext/erpnext/controllers/accounts_controller.py +321,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Višestruki fiskalne godine postoje za datum {0}. Molimo podesite kompanije u fiskalnoj godini
DocType: Education Settings,Instructor Records to be created by,Instruktorske zapise koje kreira
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} kreirao
DocType: GST Account,GST Account,GST račun
DocType: Delivery Note Item,Against Sales Order,Protiv prodajnog naloga
,Serial No Status,Serijski Bez Status
DocType: Payment Entry Reference,Outstanding,izvanredan
DocType: Supplier,Warn POs,Upozorite PO
,Daily Timesheet Summary,Dnevni Timesheet Pregled
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}","Red {0}: {1} Za postavljanje periodici, razlika između od i do danas \
 mora biti veći ili jednak {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,To se temelji na zalihama pokreta. Vidi {0} za detalje
DocType: Pricing Rule,Selling,Prodaja
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +394,Amount {0} {1} deducted against {2},Broj {0} {1} oduzeti protiv {2}
DocType: Sales Person,Name and Employee ID,Ime i ID zaposlenika
apps/erpnext/erpnext/accounts/party.py +338,Due Date cannot be before Posting Date,Datum dospijeća ne može biti prije datuma objavljivanja
DocType: Website Item Group,Website Item Group,Web stranica artikla Grupa
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +546,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Nijedan obrazovni list koji je dostavljen za navedene kriterijume ILI već dostavljen
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +160,Duties and Taxes,Carine i porezi
DocType: Projects Settings,Projects Settings,Postavke projekata
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +392,Please enter Reference date,Unesite Referentni datum
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} unosi isplate ne mogu biti filtrirani po {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,Sto za stavku koja će se prikazati u Web Site
DocType: Purchase Order Item Supplied,Supplied Qty,Isporučeni Količina
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR-YYYY.-
DocType: Purchase Order Item,Material Request Item,Materijal Zahtjev artikla
apps/erpnext/erpnext/assets/doctype/asset/asset.py +294,Please cancel Purchase Receipt {0} first,Molim poništite prvo kupoprodajni nalog {0}
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Tree stavke skupina .
DocType: Production Plan,Total Produced Qty,Ukupno proizvedeni količina
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +190,Cannot refer row number greater than or equal to current row number for this Charge type,Ne mogu se odnositi broj retka veći ili jednak trenutnom broju red za ovu vrstu Charge
DocType: Asset,Sold,prodan
,Item-wise Purchase History,Stavka-mudar Kupnja Povijest
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Molimo kliknite na ""Generiraj raspored ' dohvatiti Serial No dodao je za točku {0}"
DocType: Account,Frozen,Zaleđeni
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +382,Vehicle Type,Tip vozila
DocType: Sales Invoice Payment,Base Amount (Company Currency),Base Iznos (Company Valuta)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +994,Raw Materials,Sirovine
DocType: Payment Reconciliation Payment,Reference Row,referentni Row
DocType: Installation Note,Installation Time,Vrijeme instalacije
DocType: Sales Invoice,Accounting Details,Računovodstvo Detalji
DocType: Shopify Settings,status html,status html
apps/erpnext/erpnext/setup/doctype/company/company.js +133,Delete all the Transactions for this Company,Izbrisati sve transakcije za ovu kompaniju
DocType: Inpatient Record,O Positive,O Pozitivno
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Investments,Investicije
DocType: Issue,Resolution Details,Detalji o rjesenju problema
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +167,Transaction Type,Tip transakcije
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Kriterij prihvaćanja
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Molimo unesite materijala Zahtjevi u gornjoj tablici
apps/erpnext/erpnext/hr/doctype/loan/loan.py +154,No repayments available for Journal Entry,Nema otplate dostupnih za unos novina
DocType: Hub Tracked Item,Image List,Lista slika
DocType: Item Attribute,Attribute Name,Atributi Ime
DocType: BOM,Show In Website,Pokaži Na web stranice
DocType: Loan Application,Total Payable Amount,Ukupan iznos
DocType: Task,Expected Time (in hours),Očekivano trajanje (u satima)
DocType: Item Reorder,Check in (group),Check in (grupa)
DocType: Soil Texture,Silt,Silt
,Qty to Order,Količina za narudžbu
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Glava račun pod odgovornošću ili Equity, u kojoj će se rezervirati Dobit / Gubitak"
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +44,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},Još jedan rekord budžeta &#39;{0}&#39; već postoji {1} &#39;{2}&#39; i račun &#39;{3}&#39; za fiskalnu godinu {4}
apps/erpnext/erpnext/config/projects.py +36,Gantt chart of all tasks.,Gantogram svih zadataka.
DocType: Opportunity,Mins to First Response,Min First Response
DocType: Pricing Rule,Margin Type,Margina Tip
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} sati
DocType: Course,Default Grading Scale,Uobičajeno Pravilo Scale
DocType: Appraisal,For Employee Name,Za ime zaposlenika
DocType: Holiday List,Clear Table,Poništi tabelu
DocType: Woocommerce Settings,Tax Account,Poreski račun
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +135,Available slots,Raspoložive slotove
DocType: C-Form Invoice Detail,Invoice No,Račun br
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +408,Make Payment,izvrši plaćanje
DocType: Room,Room Name,Soba Naziv
DocType: Prescription Duration,Prescription Duration,Trajanje recepta
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Ostavite ne može se primijeniti / otkazan prije nego {0}, kao odsustvo ravnoteža je već carry-proslijeđen u budućnosti rekord raspodjeli odsustvo {1}"
DocType: Activity Cost,Costing Rate,Costing Rate
apps/erpnext/erpnext/config/selling.py +234,Customer Addresses And Contacts,Adrese i kontakti kupaca
,Campaign Efficiency,kampanja efikasnost
DocType: Discussion,Discussion,rasprava
DocType: Payment Entry,Transaction ID,transakcija ID
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,Odbitak poreza za neosnovan dokaz o oslobađanju od poreza
DocType: Volunteer,Anytime,Uvek
DocType: Bank Account,Bank Account No,Bankarski račun br
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,Podnošenje dokaza o izuzeću poreza na radnike
DocType: Patient,Surgical History,Hirurška istorija
DocType: Bank Statement Settings Item,Mapped Header,Mapped Header
DocType: Employee,Resignation Letter Date,Ostavka Pismo Datum
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Pravilnik o određivanju cijena dodatno se filtrira na temelju količine.
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +115,Not Set,ne Set
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +417,Please set the Date Of Joining for employee {0},Molimo vas da postavite datum ulaska za zaposlenog {0}
DocType: Inpatient Record,Discharge,Pražnjenje
DocType: Task,Total Billing Amount (via Time Sheet),Ukupno Billing Iznos (preko Time Sheet)
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Ponovite Customer prihoda
DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
DocType: Bank Statement Settings,Mapped Items,Mapped Items
DocType: Amazon MWS Settings,IT,IT
DocType: Chapter,Chapter,Poglavlje
apps/erpnext/erpnext/utilities/user_progress.py +146,Pair,Par
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Podrazumevani nalog će se automatski ažurirati u POS računu kada je izabran ovaj režim.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1045,Select BOM and Qty for Production,Odaberite BOM i količina za proizvodnju
DocType: Asset,Depreciation Schedule,Amortizacija Raspored
apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Prodajni partner adrese i kontakti
DocType: Bank Reconciliation Detail,Against Account,Protiv računa
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +84,Half Day Date should be between From Date and To Date,Poludnevni datum treba biti između Od datuma i Do datuma
DocType: Maintenance Schedule Detail,Actual Date,Stvarni datum
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +135,Please set the Default Cost Center in {0} company.,Molimo da podesite Centar za podrazumevane troškove u kompaniji {0}.
DocType: Item,Has Batch No,Je Hrpa Ne
apps/erpnext/erpnext/public/js/utils.js +107,Annual Billing: {0},Godišnji Billing: {0}
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Shopify Webhook Detail
apps/erpnext/erpnext/config/accounts.py +228,Goods and Services Tax (GST India),Poreska dobara i usluga (PDV Indija)
DocType: Delivery Note,Excise Page Number,Trošarina Broj stranice
DocType: Asset,Purchase Date,Datum kupovine
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +33,Could not generate Secret,Nije moguće generirati tajnu
DocType: Volunteer,Volunteer Type,Volonterski tip
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-YYYY.-
DocType: Shift Assignment,Shift Type,Tip pomaka
DocType: Student,Personal Details,Osobni podaci
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +199,Please set 'Asset Depreciation Cost Center' in Company {0},Molimo podesite &#39;Asset Amortizacija troškova Center&#39; u kompaniji {0}
,Maintenance Schedules,Rasporedi održavanja
DocType: Task,Actual End Date (via Time Sheet),Stvarni Završni datum (preko Time Sheet)
DocType: Soil Texture,Soil Type,Vrsta zemljišta
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +389,Amount {0} {1} against {2} {3},Broj {0} {1} protiv {2} {3}
,Quotation Trends,Trendovi ponude
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +166,Item Group not mentioned in item master for item {0},Stavka artikla se ne spominje u master artiklu za artikal {0}
DocType: GoCardless Mandate,GoCardless Mandate,GoCardless Mandate
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +439,Debit To account must be a Receivable account,Debit na račun mora biti potraživanja računa
DocType: Shipping Rule,Shipping Amount,Iznos transporta
DocType: Supplier Scorecard Period,Period Score,Ocena perioda
apps/erpnext/erpnext/public/js/event.js +19,Add Customers,Dodaj Kupci
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Iznos na čekanju
DocType: Lab Test Template,Special,Poseban
DocType: Loyalty Program,Conversion Factor,Konverzijski faktor
DocType: Purchase Order,Delivered,Isporučeno
,Vehicle Expenses,Troškovi vozila
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,Napravite laboratorijske testove na računu za prodaju
DocType: Serial No,Invoice Details,Račun Detalji
DocType: Grant Application,Show on Website,Show on Website
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Počnite
DocType: Hub Tracked Item,Hub Category,Glavna kategorija
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Broj vozila
DocType: Loan,Loan Amount,Iznos kredita
DocType: Student Report Generation Tool,Add Letterhead,Dodaj slovo
DocType: Program Enrollment,Self-Driving Vehicle,Self-vožnje vozila
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Standing Scorecard Standing
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +464,Row {0}: Bill of Materials not found for the Item {1},Red {0}: Bill materijala nije pronađen za stavku {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +112,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Ukupno izdvojene lišće {0} ne može biti manja od već odobrenih lišće {1} za period
DocType: Contract Fulfilment Checklist,Requirement,Zahtev
DocType: Journal Entry,Accounts Receivable,Konto potraživanja
DocType: Travel Itinerary,Meal Preference,Preferencija za obrok
,Supplier-Wise Sales Analytics,Supplier -mudar prodaje Analytics
DocType: Purchase Invoice,Availed ITC Central Tax,Izvršio ITC Centralni porez
DocType: Sales Invoice,Company Address Name,Kompanija adresa Ime
DocType: Work Order,Use Multi-Level BOM,Koristite multi-level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Uključi pomirio objave
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Roditelja za golf (Ostavite prazno, ako to nije dio roditelja naravno)"
DocType: Leave Control Panel,Leave blank if considered for all employee types,Ostavite prazno ako smatra za sve tipove zaposlenika
DocType: Landed Cost Voucher,Distribute Charges Based On,Podijelite Optužbe na osnovu
DocType: Projects Settings,Timesheets,Timesheets
DocType: HR Settings,HR Settings,Podešavanja ljudskih resursa
DocType: Salary Slip,net pay info,neto plata info
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +334,CESS Amount,CESS Iznos
DocType: Woocommerce Settings,Enable Sync,Omogući sinhronizaciju
DocType: Tax Withholding Rate,Single Transaction Threshold,Pojedinačni transakcioni prag
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Ova vrijednost se ažurira na listi podrazumevanih prodajnih cijena.
DocType: Email Digest,New Expenses,novi Troškovi
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +102,PDC/LC Amount,PDC / LC Iznos
DocType: Shareholder,Shareholder,Akcionar
DocType: Purchase Invoice,Additional Discount Amount,Dodatni popust Iznos
DocType: Cash Flow Mapper,Position,Pozicija
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1797,Get Items from Prescriptions,Dobijte stavke iz recepta
DocType: Patient,Patient Details,Detalji pacijenta
DocType: Inpatient Record,B Positive,B Pozitivan
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +31,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
			amount",Maksimalna korist zaposlenog {0} prelazi {1} za sumu {2} prethodnog zahtijevnog \ iznosa
apps/erpnext/erpnext/controllers/accounts_controller.py +655,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Količina mora biti 1, kao stavka je osnovno sredstvo. Molimo koristite posebnom redu za više kom."
DocType: Leave Block List Allow,Leave Block List Allow,Ostavite Blok Popis Dopustite
apps/erpnext/erpnext/setup/doctype/company/company.py +349,Abbr can not be blank or space,Skraćeno ne može biti prazan ili prostora
DocType: Patient Medical Record,Patient Medical Record,Medicinski zapis pacijenta
apps/erpnext/erpnext/accounts/doctype/account/account.js +67,Group to Non-Group,Grupa Non-grupa
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,sportovi
DocType: Loan Type,Loan Name,kredit ime
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +85,Total Actual,Ukupno Actual
DocType: Student Siblings,Student Siblings,student Siblings
DocType: Subscription Plan Detail,Subscription Plan Detail,Detalji pretplate
apps/erpnext/erpnext/utilities/user_progress.py +146,Unit,jedinica
apps/erpnext/erpnext/stock/get_item_details.py +157,Please specify Company,Navedite tvrtke
,Customer Acquisition and Loyalty,Stjecanje kupaca i lojalnost
DocType: Asset Maintenance Task,Maintenance Task,Zadatak održavanja
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +125,Please set B2C Limit in GST Settings.,Molimo postavite B2C Limit u GST Settings.
DocType: Marketplace Settings,Marketplace Settings,Postavke tržišta
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Skladište gdje ste održavanju zaliha odbijenih stavki
DocType: Work Order,Skip Material Transfer,Preskočite Prijenos materijala
apps/erpnext/erpnext/setup/utils.py +112,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nije moguće pronaći kurs za {0} do {1} za ključni datum {2}. Molimo vas da ručno stvoriti Mjenjačnica rekord
DocType: POS Profile,Price List,Cjenik
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} je podrazumijevana Fiskalna godina . Osvježite svoj browserda bi se izmjene primijenile.
apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,Trošak potraživanja
DocType: Issue,Support,Podrška
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,Ukupan iznos oslobađanja
,BOM Search,BOM pretraga
DocType: Project,Total Consumed Material Cost  (via Stock Entry),Ukupni troškovi potrošnje materijala (preko zaliha zaliha)
DocType: Subscription,Subscription Period,Period pretplate
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +169,To Date cannot be less than From Date,Datum ne može biti manji od datuma
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Objavite &quot;Na lageru&quot; ili &quot;Nema na lageru&quot; na Hub-u na osnovu raspoloživih zaliha u ovom skladištu.
DocType: Vehicle,Fuel Type,Vrsta goriva
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Navedite valuta u Company
DocType: Workstation,Wages per hour,Plaće po satu
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},Stock balans u Batch {0} će postati negativan {1} {2} za tačka na skladištu {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Nakon materijala Zahtjevi su automatski podignuta na osnovu nivou ponovnog reda stavke
apps/erpnext/erpnext/controllers/accounts_controller.py +361,Account {0} is invalid. Account Currency must be {1},Račun {0} je nevažeća. Račun valuta mora biti {1}
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +31,From Date {0} cannot be after employee's relieving Date {1},Od datuma {0} ne može biti poslije otpuštanja zaposlenog Datum {1}
DocType: Supplier,Is Internal Supplier,Je interni snabdevač
DocType: Employee,Create User Permission,Kreirajte dozvolu korisnika
DocType: Employee Benefit Claim,Employee Benefit Claim,Zahtev za naknade zaposlenima
DocType: Healthcare Settings,Remind Before,Podsjeti prije
apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Faktor UOM pretvorbe je potrebno u redu {0}
DocType: Production Plan Item,material_request_item,material_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1120,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Referenca Vrsta dokumenta mora biti jedan od prodajnog naloga, prodaje fakture ili Journal Entry"
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1 Loyalty Bodovi = Kolika osnovna valuta?
DocType: Salary Component,Deduction,Odbitak
DocType: Item,Retain Sample,Zadrži uzorak
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +109,Row {0}: From Time and To Time is mandatory.,Red {0}: Od vremena i do vremena je obavezno.
DocType: Stock Reconciliation Item,Amount Difference,iznos Razlika
apps/erpnext/erpnext/stock/get_item_details.py +416,Item Price added for {0} in Price List {1},Stavka Cijena je dodao za {0} u {1} Cjenik
DocType: Delivery Stop,Order Information,Informacije o porudžbini
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Unesite zaposlenih Id ove prodaje osoba
DocType: Territory,Classification of Customers by region,Klasifikacija Kupci po regiji
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +78,In Production,U proizvodnji
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +66,Difference Amount must be zero,Razlika iznos mora biti nula
DocType: Project,Gross Margin,Bruto marža
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +74,{0} applicable after {1} working days,{0} primjenjiv nakon {1} radnih dana
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +60,Please enter Production Item first,Unesite Proizvodnja predmeta prvi
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Izračunato Banka bilans
DocType: Normal Test Template,Normal Test Template,Normalni testni šablon
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,invaliditetom korisnika
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +970,Quotation,Ponude
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1034,Cannot set a received RFQ to No Quote,Ne možete postaviti primljeni RFQ na No Quote
DocType: Salary Slip,Total Deduction,Ukupno Odbitak
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +22,Select an account to print in account currency,Izaberite nalog za štampanje u valuti računa
,Production Analytics,proizvodnja Analytics
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog pacijenta. Za detalje pogledajte vremenski okvir ispod
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +213,Cost Updated,Troškova Ažurirano
DocType: Inpatient Record,Date of Birth,Datum rođenja
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136,Item {0} has already been returned,Artikal {0} je već vraćen
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiskalna godina ** predstavlja finansijske godine. Svi računovodstvene stavke i drugih većih transakcija se prate protiv ** Fiskalna godina **.
DocType: Opportunity,Customer / Lead Address,Kupac / Adresa Lead-a
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Podešavanje Scorecard-a
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Naziv plana procene
DocType: Work Order Operation,Work Order Operation,Operacija rada
apps/erpnext/erpnext/stock/doctype/item/item.py +248,Warning: Invalid SSL certificate on attachment {0},Upozorenje: Invalid SSL certifikat o prilogu {0}
apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Leads biste se lakše poslovanje, dodati sve svoje kontakte i još kao vodi"
DocType: Work Order Operation,Actual Operation Time,Stvarni Operation Time
DocType: Authorization Rule,Applicable To (User),Odnosi se na (Upute)
DocType: Purchase Taxes and Charges,Deduct,Odbiti
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +219,Job Description,Opis posla
DocType: Student Applicant,Applied,Applied
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +934,Re-open,Ponovno otvorena
DocType: Sales Invoice Item,Qty as per Stock UOM,Količina po burzi UOM
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 ime
DocType: Attendance,Attendance Request,Zahtev za prisustvo
DocType: Purchase Invoice,02-Post Sale Discount,Popust za prodaju 02-post
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +139,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Specijalni znakovi osim ""-"" ""."", ""#"", i ""/"" nije dozvoljeno u imenovanju serije"
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Pratite prodajne kampanje. Pratite Lead-ove, Ponude, Porudžbenice itd iz Kampanje i procijeniti povrat investicije."
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +115,You can't redeem Loyalty Points having more value than the Grand Total.,Ne možete otkupiti Loyalty Points sa više vrijednosti nego Grand Total.
DocType: Department Approver,Approver,Odobritelj
,SO Qty,SO Kol
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +92,The field To Shareholder cannot be blank,Polje Za dioničara ne može biti prazno
DocType: Guardian,Work Address,rad Adresa
DocType: Appraisal,Calculate Total Score,Izračunaj ukupan rezultat
DocType: Employee,Health Insurance,Zdravstveno osiguranje
DocType: Asset Repair,Manufacturing Manager,Proizvodnja Manager
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serijski Ne {0} je pod jamstvom upto {1}
DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimalna dozvoljena vrijednost
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41,User {0} already exists,Korisnik {0} već postoji
apps/erpnext/erpnext/hooks.py +115,Shipments,Pošiljke
DocType: Payment Entry,Total Allocated Amount (Company Currency),Ukupan dodijeljeni iznos (Company Valuta)
DocType: Purchase Order Item,To be delivered to customer,Dostaviti kupcu
DocType: BOM,Scrap Material Cost,Otpadnog materijala troškova
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +243,Serial No {0} does not belong to any Warehouse,Serijski broj {0} ne pripada nijednoj Skladište
DocType: Grant Application,Email Notification Sent,Poslato obaveštenje o pošti
DocType: Purchase Invoice,In Words (Company Currency),Riječima (valuta tvrtke)
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py +24,Company is manadatory for company account,Kompanija je umanjena za račun kompanije
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1084,"Item Code, warehouse, quantity are required on row","Šifra proizvoda, skladište, količina su potrebna u redu"
DocType: Bank Guarantee,Supplier,Dobavljači
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +9,Get From,Dobiti od
apps/erpnext/erpnext/hr/doctype/department/department.js +9,This is a root department and cannot be edited.,Ovo je korijensko odjeljenje i ne može se uređivati.
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Prikaži podatke o plaćanju
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +53,Duration in Days,Trajanje u danima
DocType: C-Form,Quarter,Četvrtina
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +113,Miscellaneous Expenses,Razni troškovi
DocType: Global Defaults,Default Company,Zadana tvrtka
DocType: Company,Transactions Annual History,Godišnja istorija transakcija
apps/erpnext/erpnext/controllers/stock_controller.py +231,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Rashodi ili razlika račun je obvezna za točke {0} jer utječe na ukupnu vrijednost dionica
DocType: Bank,Bank Name,Naziv banke
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +33,-Above,Iznad
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1218,Leave the field empty to make purchase orders for all suppliers,Ostavite polje prazno da biste naručili naloge za sve dobavljače
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Obavezna posjeta obaveznoj posjeti
DocType: Vital Signs,Fluid,Fluid
DocType: Leave Application,Total Leave Days,Ukupno Ostavite Dani
DocType: Email Digest,Note: Email will not be sent to disabled users,Napomena: E-mail neće biti poslan invalide
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Broj Interaction
apps/erpnext/erpnext/stock/doctype/item/item.js +107,Item Variant Settings,Postavke varijante postavki
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37,Select Company...,Odaberite preduzeće...
DocType: Leave Control Panel,Leave blank if considered for all departments,Ostavite prazno ako smatra za sve odjele
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +505,{0} is mandatory for Item {1},{0} je obavezno za tu stavku {1}
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136,"Item {0}: {1} qty produced, ","Stavka {0}: {1} količina proizvedena,"
DocType: Payroll Entry,Fortnightly,četrnaestodnevni
DocType: Currency Exchange,From Currency,Od novca
DocType: Vital Signs,Weight (In Kilogram),Težina (u kilogramu)
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",poglavlja / chapter_name ostavite prazno automatski nakon podešavanja poglavlja.
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +218,Please set GST Accounts in GST Settings,Molimo postavite GST račune u GST podešavanjima
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +46,Type of Business,Tip poslovanja
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Molimo odaberite Izdvojena količina, vrsta fakture i fakture Broj u atleast jednom redu"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +143,Cost of New Purchase,Troškovi New Kupovina
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +98,Sales Order required for Item {0},Prodajnog naloga potrebna za točke {0}
DocType: Grant Application,Grant Description,Grant Opis
DocType: Purchase Invoice Item,Rate (Company Currency),Ocijeni (Društvo valuta)
DocType: Student Guardian,Others,Drugi
DocType: Subscription,Discounts,Popusti
DocType: Payment Entry,Unallocated Amount,neraspoređenih Iznos
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +77,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,Molimo omogućite primenljivu na nalogu za kupovinu i primenljivu na trenutnim troškovima rezervacije
apps/erpnext/erpnext/templates/includes/product_page.js +101,Cannot find a matching Item. Please select some other value for {0}.,Ne možete pronaći stavku koja se podudara. Molimo odaberite neki drugi vrijednost za {0}.
DocType: POS Profile,Taxes and Charges,Porezi i naknade
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Proizvoda ili usluge koja je kupio, prodati ili držati u čoporu."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Nema više ažuriranja
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +184,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Ne možete odabrati vrstu naboja kao ' na prethodnim Row Iznos ""ili"" u odnosu na prethodnu Row Ukupno ""za prvi red"
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-YYYY.-
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Ovo pokriva sve sisteme rezultata povezanih sa ovim postavkama
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,Dijete Stavka ne bi trebao biti proizvod Bundle. Molimo vas da uklonite stavku `{0}` i uštedite
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Bankarstvo
apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Dodaj Timesheets
DocType: Vehicle Service,Service Item,Servis Stavka
DocType: Bank Guarantee,Bank Guarantee,Bankarska garancija
DocType: Payment Request,Transaction Details,Detalji transakcije
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,"Molimo kliknite na ""Generiraj raspored ' kako bi dobili raspored"
DocType: Blanket Order Item,Ordered Quantity,Naručena količina
apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","na primjer "" Izgraditi alate za graditelje """
DocType: Grading Scale,Grading Scale Intervals,Pravilo Scale Intervali
DocType: Item Default,Purchase Defaults,Kupovina Defaults
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117,Make Job Card,Napravite karticu za posao
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +326,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again","Ne mogu automatski da kreiram kreditnu poruku, molim da uklonite oznaku &#39;Izdavanje kreditne note&#39; i pošaljite ponovo"
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Dobit za godinu
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +126,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Računovodstvo Ulaz za {2} može se vršiti samo u valuti: {3}
DocType: Fee Schedule,In Process,U procesu
DocType: Authorization Rule,Itemwise Discount,Itemwise Popust
apps/erpnext/erpnext/config/accounts.py +92,Tree of financial accounts.,Tree financijskih računa.
DocType: Bank Guarantee,Reference Document Type,Referentni dokument Tip
DocType: Cash Flow Mapping,Cash Flow Mapping,Mapiranje tokova gotovine
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +400,{0} against Sales Order {1},{0} protiv naloga prodaje {1}
DocType: Account,Fixed Asset,Dugotrajne imovine
DocType: Amazon MWS Settings,After Date,Posle Datuma
apps/erpnext/erpnext/config/stock.py +327,Serialized Inventory,Serijalizovanoj zaliha
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1166,Invalid {0} for Inter Company Invoice.,Invalid {0} za Inter Company račun.
,Department Analytics,Odjel analitike
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,E-pošta nije pronađena u podrazumevanom kontaktu
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +23,Generate Secret,Generiraj tajnu
DocType: Loan,Account Info,Account Info
DocType: Activity Type,Default Billing Rate,Uobičajeno Billing Rate
DocType: Fees,Include Payment,Uključi plaćanje
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} studentskih grupa stvorio.
DocType: Sales Invoice,Total Billing Amount,Ukupan iznos naplate
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Program u strukturi naknada i studentskoj grupi {0} su različiti.
DocType: Bank Statement Transaction Entry,Receivable Account,Potraživanja račun
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +31,Valid From Date must be lesser than Valid Upto Date.,Važi od datuma mora biti manji od važećeg datuma.
apps/erpnext/erpnext/controllers/accounts_controller.py +673,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} je već {2}
DocType: Quotation Item,Stock Balance,Kataloški bilanca
apps/erpnext/erpnext/config/selling.py +327,Sales Order to Payment,Naloga prodaje na isplatu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +111,CEO,CEO
DocType: Purchase Invoice,With Payment of Tax,Uz plaćanje poreza
DocType: Expense Claim Detail,Expense Claim Detail,Rashodi Zahtjev Detalj
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,Tri primjerka ZA SUPPLIER
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,Novo stanje u osnovnoj valuti
DocType: Location,Is Container,Je kontejner
DocType: Crop Cycle,This will be day 1 of the crop cycle,Ovo će biti dan 1 ciklusa usjeva
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +915,Please select correct account,Molimo odaberite ispravan račun
DocType: Salary Structure Assignment,Salary Structure Assignment,Dodjela strukture plata
DocType: Purchase Invoice Item,Weight UOM,Težina UOM
apps/erpnext/erpnext/config/accounts.py +510,List of available Shareholders with folio numbers,Spisak dostupnih akcionara sa brojevima folije
DocType: Salary Structure Employee,Salary Structure Employee,Plaća Struktura zaposlenih
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +56,Show Variant Attributes,Prikaži varijante atributa
DocType: Student,Blood Group,Krvna grupa
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +48,The payment gateway account in plan {0} is different from the payment gateway account in this payment request,Račun plaćačkog plaćanja u planu {0} razlikuje se od naloga za plaćanje u ovom zahtjevu za plaćanje
DocType: Course,Course Name,Naziv predmeta
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py +50,No Tax Withholding data found for the current Fiscal Year.,Nije pronađen nikakav porezni zadatak za tekuću fiskalnu godinu.
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Korisnici koji može odobriti odsustvo aplikacije određenu zaposlenog
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +53,Office Equipments,uredske opreme
DocType: Purchase Invoice Item,Qty,Kol
DocType: Fiscal Year,Companies,Companies
DocType: Supplier Scorecard,Scoring Setup,Podešavanje bodova
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronika
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +359,Debit ({0}),Debit ({0})
DocType: BOM,Allow Same Item Multiple Times,Dozvolite istu stavku više puta
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Podignite Materijal Zahtjev kad dionica dosegne ponovno poredak razinu
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Full-time,Puno radno vrijeme
DocType: Payroll Entry,Employees,Zaposleni
DocType: Employee,Contact Details,Kontakt podaci
DocType: C-Form,Received Date,Datum pozicija
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ako ste kreirali standardni obrazac u prodaji poreza i naknada Template, odaberite jednu i kliknite na dugme ispod."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Osnovni Iznos (Company Valuta)
DocType: Student,Guardians,čuvari
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13,Payment Confirmation,Potvrda o plaćanju
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Cijene neće biti prikazan ako nije postavljena Cjenik
DocType: Stock Entry,Total Incoming Value,Ukupna vrijednost Incoming
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +433,Debit To is required,To je potrebno Debit
DocType: Clinical Procedure,Inpatient Record,Zapisnik o stacionarnom stanju
apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets pomoći pratiti vremena, troškova i naplate za aktivnostima obavlja svoj tim"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +41,Purchase Price List,Kupoprodajna cijena List
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +161,Date of Transaction,Datum transakcije
apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Šabloni varijabli indeksa dobavljača.
DocType: Job Offer Term,Offer Term,Ponuda Term
DocType: Asset,Quality Manager,Quality Manager
DocType: Job Applicant,Job Opening,Posao Otvaranje
DocType: Payment Reconciliation,Payment Reconciliation,Pomirenje plaćanja
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Odaberite incharge ime osobe
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,tehnologija
apps/erpnext/erpnext/public/js/utils.js +109,Total Unpaid: {0},Ukupno Neplaćeni: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Web Operacija
DocType: Bank Statement Transaction Payment Item,outstanding_amount,preostali iznos
DocType: Supplier Scorecard,Supplier Score,Ocjena dobavljača
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js +37,Schedule Admission,Raspored prijema
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,Kumulativni prag transakcije
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +231,Total Invoiced Amt,Ukupno Fakturisana Amt
DocType: Supplier,Warn RFQs,Upozorite RFQs
DocType: BOM,Conversion Rate,Stopa konverzije
apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Traži proizvod
DocType: Cashier Closing,To Time,Za vrijeme
apps/erpnext/erpnext/hr/utils.py +201,) for {0},) za {0}
DocType: Authorization Rule,Approving Role (above authorized value),Odobravanje ulogu (iznad ovlašteni vrijednost)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +146,Credit To account must be a Payable account,Credit na račun mora biti računa se plaćaju
DocType: Loan,Total Amount Paid,Ukupan iznos plaćen
DocType: Asset,Insurance End Date,Krajnji datum osiguranja
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Molimo izaberite Studentski prijem koji je obavezan za učeniku koji je platio
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +365,BOM recursion: {0} cannot be parent or child of {2},BOM rekurzija : {0} ne može biti roditelj ili dijete od {2}
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +40,Budget List,Budžetska lista
DocType: Work Order Operation,Completed Qty,Završen Kol
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +180,"For {0}, only debit accounts can be linked against another credit entry","Za {0}, samo debitne račune mogu povezati protiv druge kreditne unos"
DocType: Manufacturing Settings,Allow Overtime,Omogućiti Prekovremeni rad
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +149,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serijalizovanoj Stavka {0} ne može se ažurirati pomoću Stock pomirenje, molimo vas da koristite Stock Entry"
DocType: Training Event Employee,Training Event Employee,Treningu zaposlenih
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1295,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maksimalni uzorci - {0} mogu biti zadržani za seriju {1} i stavku {2}.
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +7,Add Time Slots,Dodajte vremenske utore
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +206,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} serijski brojevi potrebni za artikal {1}. koji ste trazili {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Trenutno Vrednovanje Rate
DocType: Training Event,Advance,Advance
apps/erpnext/erpnext/config/integrations.py +13,GoCardless payment gateway settings,GoCardless postavke gateway plaćanja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Exchange Gain/Loss,Exchange dobitak / gubitak
DocType: Opportunity,Lost Reason,Razlog gubitka
DocType: Amazon MWS Settings,Enable Amazon,Omogućite Amazon
apps/erpnext/erpnext/controllers/accounts_controller.py +312,Row #{0}: Account {1} does not belong to company {2},Red # {0}: Račun {1} ne pripada kompaniji {2}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},Nije moguće pronaći DocType {0}
apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Nova adresa
DocType: Quality Inspection,Sample Size,Veličina uzorka
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Unesite dokument o prijemu
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +411,All items have already been invoiced,Svi artikli su već fakturisani
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',Navedite važeću &#39;iz Predmet br&#39;
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,"Dalje troška mogu biti pod Grupe, ali unosa može biti protiv ne-Grupe"
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +40,Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,Ukupno dodijeljeno liste su više dana od maksimalne dodjele tipa {0} za zaposlenog {1} u tom periodu
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Korisnici i dozvole
DocType: Branch,Branch,Ogranak
DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
DocType: Delivery Trip,Fulfillment User,Fulfillment User
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Tiskanje i brendiranje
DocType: Company,Total Monthly Sales,Ukupna mesečna prodaja
DocType: Payment Request,Subscription Plans,Planovi pretplate
DocType: Agriculture Analysis Criteria,Weather,Vrijeme
DocType: Bin,Actual Quantity,Stvarna količina
DocType: Shipping Rule,example: Next Day Shipping,Primjer: Sljedeći dan Dostava
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Serial No {0} nije pronađena
DocType: Fee Schedule Program,Fee Schedule Program,Program raspoređivanja naknada
DocType: Fee Schedule Program,Student Batch,student Batch
apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Make Student
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min razred
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,Vrsta jedinice za zdravstvenu zaštitu
apps/erpnext/erpnext/projects/doctype/project/project.py +279,You have been invited to collaborate on the project: {0},Vi ste pozvani da surađuju na projektu: {0}
DocType: Supplier Group,Parent Supplier Group,Matična grupa dobavljača
DocType: Email Digest,Purchase Orders to Bill,Narudžbe za kupovinu
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +47,Accumulated Values in Group Company,Akumulirane vrijednosti u grupnoj kompaniji
DocType: Leave Block List Date,Block Date,Blok Datum
DocType: Crop,Crop,Rezati
DocType: Purchase Receipt,Supplier Delivery Note,Napomena o isporuci dobavljača
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Prijavite se sada
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,Vrsta dokaza
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Stvarni Količina {0} / Waiting Količina {1}
DocType: Purchase Invoice,E-commerce GSTIN,E-trgovina GSTIN
DocType: Sales Order,Not Delivered,Ne Isporučeno
,Bank Clearance Summary,Razmak banka Sažetak
apps/erpnext/erpnext/config/setup.py +100,"Create and manage daily, weekly and monthly email digests.","Stvaranje i upravljanje dnevne , tjedne i mjesečne e razgradnju ."
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_dashboard.py +6,This is based on transactions against this Sales Person. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog Prodavca. Za detalje pogledajte vremenski okvir ispod
DocType: Appraisal Goal,Appraisal Goal,Procjena gol
DocType: Stock Reconciliation Item,Current Amount,Trenutni iznos
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +59,Buildings,zgrade
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py +24,Tax Declaration of {0} for period {1} already submitted.,Poreska deklaracija {0} za period {1} je već podneta.
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +76,Leaves has been granted sucessfully,Lišće je uspešno izdato
DocType: Fee Schedule,Fee Structure,naknada Struktura
DocType: Timesheet Detail,Costing Amount,Costing Iznos
DocType: Student Admission Program,Application Fee,naknada aplikacija
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +75,Submit Salary Slip,Slanje plaće Slip
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +13,On Hold,Na čekanju
DocType: Account,Inter Company Account,Inter Company Account
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +17,Import in Bulk,Uvoz u rinfuzi
DocType: Sales Partner,Address & Contacts,Adresa i kontakti
DocType: SMS Log,Sender Name,Ime / Naziv pošiljaoca
DocType: Vital Signs,Very Hyper,Veoma Hyper
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kriterijumi za analizu poljoprivrede
DocType: HR Settings,Leave Approval Notification Template,Napustite šablon za upozorenje o odobrenju
DocType: POS Profile,[Select],[ izaberite ]
DocType: Staffing Plan Detail,Number Of Positions,Broj pozicija
DocType: Vital Signs,Blood Pressure (diastolic),Krvni pritisak (dijastolni)
DocType: SMS Log,Sent To,Poslati
DocType: Agriculture Task,Holiday Management,Holiday Management
DocType: Payment Request,Make Sales Invoice,Ostvariti prodaju fakturu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +62,Softwares,softvera
apps/erpnext/erpnext/crm/doctype/lead/lead.py +53,Next Contact Date cannot be in the past,Sljedeća Kontakt datum ne može biti u prošlosti
DocType: Company,For Reference Only.,Za referencu samo.
apps/erpnext/erpnext/accounts/page/pos/pos.js +2592,Select Batch No,Izaberite serijski br
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +79,Invalid {0}: {1},{1}: Invalid {0}
,GSTR-1,GSTR-1
DocType: Fee Validity,Reference Inv,Reference Inv
DocType: Sales Invoice Advance,Advance Amount,Iznos avansa
DocType: Manufacturing Settings,Capacity Planning,Planiranje kapaciteta
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Prilagođavanje zaokruživanja (valuta kompanije
DocType: Asset,Policy number,Broj police
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,' Od datuma ' je potrebno
DocType: Journal Entry,Reference Number,Referentni broj
DocType: Employee,New Workplace,Novi radnom mjestu
DocType: Retention Bonus,Retention Bonus,Bonus za zadržavanje
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +458,Material Consumption,Potrošnja materijala
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Postavi status Zatvoreno
apps/erpnext/erpnext/stock/get_item_details.py +146,No Item with Barcode {0},No Stavka s Barcode {0}
DocType: Normal Test Items,Require Result Value,Zahtevaj vrednost rezultata
DocType: Item,Show a slideshow at the top of the page,Prikaži slideshow na vrhu stranice
DocType: Tax Withholding Rate,Tax Withholding Rate,Stopa zadržavanja poreza
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +546,Boms,Boms
apps/erpnext/erpnext/stock/doctype/item/item.py +177,Stores,prodavaonice
DocType: Project Type,Projects Manager,Projektni menadzer
DocType: Serial No,Delivery Time,Vrijeme isporuke
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +45,Ageing Based On,Starenje temelju On
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +103,Appointment cancelled,Imenovanje je otkazano
DocType: Item,End of Life,Kraj života
apps/erpnext/erpnext/demo/setup/setup_data.py +325,Travel,putovanje
DocType: Student Report Generation Tool,Include All Assessment Group,Uključite svu grupu procene
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,No active or default Salary Structure found for employee {0} for the given dates,Nema aktivnih ili zadani Plaća Struktura nađeni za zaposlenog {0} za navedeni datumi
DocType: Leave Block List,Allow Users,Omogućiti korisnicima
DocType: Purchase Order,Customer Mobile No,Mobilni broj kupca
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Detalji šablona za mapiranje gotovog toka
apps/erpnext/erpnext/config/non_profit.py +68,Loan Management,Upravljanje zajmovima
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Pratite odvojene prihoda i rashoda za vertikala proizvod ili podjele.
DocType: Rename Tool,Rename Tool,Preimenovanje alat
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +81,Update Cost,Update cost
DocType: Item Reorder,Item Reorder,Ponovna narudžba artikla
DocType: Delivery Note,Mode of Transport,Način transporta
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +448,Show Salary Slip,Pokaži Plaća Slip
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +873,Transfer Material,Prijenos materijala
DocType: Fees,Send Payment Request,Pošaljite zahtev za plaćanje
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Navedite operacija, operativni troškovi i dati jedinstven radom najkasnije do svojih operacija ."
DocType: Travel Request,Any other details,Bilo koji drugi detalj
DocType: Water Analysis,Origin,Poreklo
apps/erpnext/erpnext/controllers/status_updater.py +207,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Ovaj dokument je preko granice po {0} {1} za stavku {4}. Da li što još {3} u odnosu na isti {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js +1221,Please set recurring after saving,Molimo podesite ponavljaju nakon spremanja
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +871,Select change amount account,Izaberite promjene iznos računa
DocType: Purchase Invoice,Price List Currency,Cjenik valuta
DocType: Naming Series,User must always select,Korisničko uvijek mora odabrati
DocType: Stock Settings,Allow Negative Stock,Dopustite negativnu zalihu
DocType: Installation Note,Installation Note,Napomena instalacije
DocType: Soil Texture,Clay,Clay
DocType: Topic,Topic,tema
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +99,Cash Flow from Financing,Novčani tok iz Financiranje
DocType: Budget Account,Budget Account,računa budžeta
DocType: Quality Inspection,Verified By,Ovjeren od strane
DocType: Travel Request,Name of Organizer,Ime organizatora
apps/erpnext/erpnext/setup/doctype/company/company.py +84,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Ne mogu promijeniti tvrtke zadanu valutu , jer postoje neki poslovi . Transakcije mora biti otkazana promijeniti zadanu valutu ."
DocType: Cash Flow Mapping,Is Income Tax Liability,Da li je porez na dohodak
DocType: Grading Scale Interval,Grade Description,Grade Opis
DocType: Clinical Procedure,Is Invoiced,Isplaćeno
DocType: Stock Entry,Purchase Receipt No,Primka br.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +31,Earnest Money,kapara
DocType: Sales Invoice, Shipping Bill Number,Broj pošiljke
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,sljedivost
DocType: Asset Maintenance Log,Actions performed,Izvršene akcije
DocType: Cash Flow Mapper,Section Leader,Rukovodilac odjela
DocType: Delivery Note,Transport Receipt No,Transportni prijem br
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +144,Source of Funds (Liabilities),Izvor sredstava ( pasiva)
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +52,Source and Target Location cannot be same,Izvor i ciljna lokacija ne mogu biti isti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +518,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina u redu {0} ( {1} ) mora biti isti kao proizvedena količina {2}
DocType: Supplier Scorecard Scoring Standing,Employee,Radnik
DocType: Bank Guarantee,Fixed Deposit Number,Fiksni depozitni broj
DocType: Asset Repair,Failure Date,Datum otkaza
DocType: Support Search Source,Result Title Field,Polje rezultata rezultata
DocType: Sample Collection,Collected Time,Prikupljeno vreme
DocType: Company,Sales Monthly History,Prodaja mesečne istorije
DocType: Asset Maintenance Task,Next Due Date,Sljedeći datum roka
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +242,Select Batch,Izaberite Batch
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,{0} {1} is fully billed,{0} {1} je u potpunosti naplaćeno
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +30,Vital Signs,Vitalni znaci
DocType: Payment Entry,Payment Deductions or Loss,Plaćanje Smanjenja ili gubitak
DocType: Soil Analysis,Soil Analysis Criterias,Kriterijumi za analizu zemljišta
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standardni uvjeti ugovora za prodaju ili kupnju.
DocType: BOM Item,Item operation,Rad operacija
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +327,Are you sure you want to cancel this appointment?,Da li ste sigurni da želite da otkažete ovaj termin?
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Paket za hotelsku sobu
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +42,Sales Pipeline,prodaja Pipeline
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +163,Please set default account in Salary Component {0},Molimo podesite zadani račun u Plaća Komponenta {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Potrebna On
DocType: Rename Tool,File to Rename,File da biste preimenovali
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Molimo odaberite BOM za Stavka zaredom {0}
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +13,Fetch Subscription Updates,Izvrši ažuriranje pretplate
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},Računa {0} ne odgovara Company {1} u režimu računa: {2}
apps/erpnext/erpnext/controllers/buying_controller.py +707,Specified BOM {0} does not exist for Item {1},Navedene BOM {0} ne postoji za Stavka {1}
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301,Course: ,Kurs:
DocType: Soil Texture,Sandy Loam,Sandy Loam
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Raspored održavanja {0} mora biti otkazana prije poništenja ovu prodajnog naloga
DocType: POS Profile,Applicable for Users,Primenljivo za korisnike
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-YYYY.-
DocType: Notification Control,Expense Claim Approved,Rashodi Zahtjev odobren
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Postavite napredak i dodelite (FIFO)
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Work Orders created,Stvaranje radnih naloga
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +403,Salary Slip of employee {0} already created for this period,Plaća listić od zaposlenika {0} već kreirali za ovaj period
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +144,Pharmaceutical,farmaceutski
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +24,You can only submit Leave Encashment for a valid encashment amount,Možete podnijeti Leave Encashment samo važeći iznos za unos
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Troškovi Kupljene stavke
DocType: Employee Separation,Employee Separation Template,Šablon za razdvajanje zaposlenih
DocType: Selling Settings,Sales Order Required,Prodajnog naloga Obvezno
apps/erpnext/erpnext/public/js/hub/marketplace.js +107,Become a Seller,Postanite Prodavac
DocType: Purchase Invoice,Credit To,Kreditne Da
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Active Leads / Customers,Aktivni Potencijani kupci / Kupci
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,Ostavite prazno da biste koristili standardni format isporuke
DocType: Employee Education,Post Graduate,Post diplomski
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Raspored održavanja detaljno
DocType: Supplier Scorecard,Warn for new Purchase Orders,Upozoriti na nova narudžbina
DocType: Quality Inspection Reading,Reading 9,Čitanje 9
DocType: Supplier,Is Frozen,Je zamrznut
apps/erpnext/erpnext/stock/utils.py +248,Group node warehouse is not allowed to select for transactions,skladište Group čvor nije dozvoljeno da izaberete za transakcije
DocType: Buying Settings,Buying Settings,Podešavanja nabavke
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM broj za Gotovi Dobar točki
DocType: Upload Attendance,Attendance To Date,Gledatelja do danas
DocType: Request for Quotation Supplier,No Quote,Nema citata
DocType: Support Search Source,Post Title Key,Ključ posta za naslov
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +232,For Job Card,Za karticu posla
DocType: Warranty Claim,Raised By,Povišena Do
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1552,Prescriptions,Prescriptions
DocType: Payment Gateway Account,Payment Account,Plaćanje računa
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +1105,Please specify Company to proceed,Navedite Tvrtka postupiti
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +81,Net Change in Accounts Receivable,Neto promjena u Potraživanja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +91,Compensatory Off,kompenzacijski Off
DocType: Job Offer,Accepted,Prihvaćeno
DocType: POS Closing Voucher,Sales Invoices Summary,Sažetak prodajnih faktura
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +225,To Party Name,U ime stranke
DocType: Grant Application,Organization,organizacija
DocType: BOM Update Tool,BOM Update Tool,Alat za ažuriranje BOM
DocType: SG Creation Tool Course,Student Group Name,Student Ime grupe
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js +23,Show exploded view,Pokažite eksplodiran pogled
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Kreiranje naknada
apps/erpnext/erpnext/setup/doctype/company/company.js +111,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.,Molimo Vas da proverite da li ste zaista želite izbrisati sve transakcije za ovu kompaniju. Tvoj gospodar podaci će ostati kao što je to. Ova akcija se ne može poništiti.
apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,Search Results
DocType: Room,Room Number,Broj sobe
apps/erpnext/erpnext/utilities/transaction_base.py +101,Invalid reference {0} {1},Invalid referentni {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}) ne može biti veći nego što je planirana kolicina ({2}) u proizvodnoj porudzbini {3}
DocType: Shipping Rule,Shipping Rule Label,Naziv pravila transporta
DocType: Journal Entry Account,Payroll Entry,Unos plata
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +76,View Fees Records,View Fees Records
apps/erpnext/erpnext/setup/doctype/company/company.js +55,Make Tax Template,Napravite poreznu šemu
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,User Forum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +328,Raw Materials cannot be blank.,Sirovine ne može biti prazan.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1022,Row #{0} (Payment Table): Amount must be negative,Red # {0} (Tabela za plaćanje): Iznos mora biti negativan
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +569,"Could not update stock, invoice contains drop shipping item.","Nije mogao ažurirati zaliha, faktura sadrži drop shipping stavke."
DocType: Contract,Fulfilment Status,Status ispune
DocType: Lab Test Sample,Lab Test Sample,Primjer laboratorijskog testa
DocType: Item Variant Settings,Allow Rename Attribute Value,Dozvoli preimenovati vrednost atributa
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +533,Quick Journal Entry,Brzi unos u dnevniku
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +244,You can not change rate if BOM mentioned agianst any item,Ne možete promijeniti brzinu ako BOM spomenuo agianst bilo predmet
DocType: Restaurant,Invoice Series Prefix,Prefix serije računa
DocType: Employee,Previous Work Experience,Radnog iskustva
apps/erpnext/erpnext/accounts/doctype/account/account.js +140,Update Account Number / Name,Ažurirajte broj računa / ime
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +413,Assign Salary Structure,Dodeli strukturu plata
DocType: Support Settings,Response Key List,Lista ključnih reagovanja
DocType: Job Card,For Quantity,Za količina
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Unesite Planirano Qty za točku {0} na redu {1}
DocType: Support Search Source,API,API
DocType: Support Search Source,Result Preview Field,Polje za pregled rezultata
DocType: Item Price,Packing Unit,Jedinica za pakovanje
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +273,{0} {1} is not submitted,{0} {1} nije proslijedjen
DocType: Subscription,Trialling,Trialling
DocType: Sales Invoice Item,Deferred Revenue,Odloženi prihodi
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Gotovinski račun će se koristiti za kreiranje prodajne fakture
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Izuzetna podkategorija
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Group / Supplier,Grupa / dobavljač dobavljača
DocType: Member,Membership Expiry Date,Datum isteka članstva
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +134,{0} must be negative in return document,{0} mora biti negativan za uzvrat dokumentu
DocType: Employee Tax Exemption Proof Submission,Submission Date,Datum podnošenja
,Minutes to First Response for Issues,Minuta na prvi odgovor na pitanja
DocType: Purchase Invoice,Terms and Conditions1,Odredbe i Conditions1
apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,U ime Instituta za koju se postavljanje ovog sistema.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Knjiženje zamrznuta do tog datuma, nitko ne može učiniti / mijenjati ulazak, osim uloge naveden u nastavku."
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Molimo spremite dokument prije stvaranja raspored za održavanje
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +45,Latest price updated in all BOMs,Posljednja cijena ažurirana u svim BOM
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Status projekta
DocType: UOM,Check this to disallow fractions. (for Nos),Provjerite to da ne dopušta frakcija. (Za br)
DocType: Student Admission Program,Naming Series (for Student Applicant),Imenovanje serija (za studentske Podnositelj zahtjeva)
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py +16,Bonus Payment Date cannot be a past date,Datum plaćanja bonusa ne može biti prošnji datum
DocType: Travel Request,Copy of Invitation/Announcement,Kopija poziva / obaveštenja
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,Raspored jedinica službe lekara
DocType: Delivery Note,Transporter Name,Transporter Ime
DocType: Authorization Rule,Authorized Value,Ovlašteni Vrijednost
DocType: BOM,Show Operations,Pokaži operacije
,Minutes to First Response for Opportunity,Minuta na prvi odgovor za Opportunity
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Absent,Ukupno Odsutan
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1060,Item or Warehouse for row {0} does not match Material Request,Artikal ili skladište za redak {0} ne odgovara Zahtjevu za materijalom
apps/erpnext/erpnext/config/stock.py +194,Unit of Measure,Jedinica mjere
DocType: Fiscal Year,Year End Date,Završni datum godine
DocType: Task Depends On,Task Depends On,Zadatak ovisi o
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1076,Opportunity,Prilika (Opportunity)
DocType: Operation,Default Workstation,Uobičajeno Workstation
DocType: Notification Control,Expense Claim Approved Message,Rashodi Zahtjev Odobren poruku
DocType: Payment Entry,Deductions or Loss,Smanjenja ili gubitak
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +279,{0} {1} is closed,{0} {1} je zatvoren
DocType: Email Digest,How frequently?,Koliko često?
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +56,Total Collected: {0},Ukupno prikupljeno: {0}
DocType: Purchase Receipt,Get Current Stock,Kreiraj trenutne zalihe
DocType: Purchase Invoice,ineligible,neupotrebljiv
apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Drvo Bill of Materials
DocType: Student,Joining Date,spajanje Datum
,Employees working on a holiday,Radnici koji rade na odmoru
,TDS Computation Summary,Pregled TDS računa
DocType: Share Balance,Current State,Trenutna drzava
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Present
DocType: Share Transfer,From Shareholder,Od dioničara
DocType: Project,% Complete Method,% Complete Način
apps/erpnext/erpnext/healthcare/setup.py +180,Drug,Lijek
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Održavanje datum početka ne može biti prije datuma isporuke za rednim brojem {0}
DocType: Job Card,Actual End Date,Stvarni datum završetka
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,Da li je usklađivanje troškova finansiranja
DocType: BOM,Operating Cost (Company Currency),Operativni trošak (Company Valuta)
DocType: Authorization Rule,Applicable To (Role),Odnosi se na (uloga)
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +10,Pending Leaves,Pending Leaves
DocType: BOM Update Tool,Replace BOM,Zamijenite BOM
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +113,Code {0} already exist,Kod {0} već postoji
DocType: Patient Encounter,Procedures,Procedure
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +36,Sales orders are not available for production,Prodajni nalozi nisu dostupni za proizvodnju
DocType: Asset Movement,Purpose,Svrha
DocType: Company,Fixed Asset Depreciation Settings,Osnovnih sredstava Amortizacija Postavke
DocType: Item,Will also apply for variants unless overrridden,Primjenjivat će se i za varijante osim overrridden
DocType: Purchase Invoice,Advances,Avansi
DocType: Work Order,Manufacture against Material Request,Proizvodnja protiv Materijal Upit
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +17,Assessment Group: ,Procena grupa:
DocType: Item Reorder,Request for,Zahtjev za
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Korisnik koji odobrava ne može biti isti kao i korisnik na kojeg se odnosi pravilo.
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Basic Rate (kao po akciji UOM)
DocType: SMS Log,No of Requested SMS,Nema traženih SMS
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +328,Leave Without Pay does not match with approved Leave Application records,Ostavite bez plate ne odgovara odobrenim Records Ostaviti Primjena
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Sljedeći koraci
DocType: Travel Request,Domestic,Domaći
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +846,Please supply the specified items at the best possible rates,Molimo vas da dostavite navedene stavke na najbolji mogući stope
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +19,Employee Transfer cannot be submitted before Transfer Date ,Transfer radnika ne može se podneti pre datuma prenosa
DocType: Certification Application,USD,Američki dolar
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js +7,Make Invoice,Napravite fakturu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +103,Remaining Balance,Preostali iznos
DocType: Selling Settings,Auto close Opportunity after 15 days,Auto blizu Opportunity nakon 15 dana
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +83,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Narudžbe za kupovinu nisu dozvoljene za {0} zbog stanja kartice koja se nalazi na {1}.
apps/erpnext/erpnext/stock/doctype/item/item.py +515,Barcode {0} is not a valid {1} code,Bar kod {0} nije važeći {1} kod
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +25,End Year,do kraja godine
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Lead%
apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Contract End Date must be greater than Date of Joining,Ugovor Datum završetka mora biti veći od dana ulaska u
DocType: Driver,Driver,Vozač
DocType: Vital Signs,Nutrition Values,Vrednosti ishrane
DocType: Lab Test Template,Is billable,Da li se može naplatiti
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,A treće strane distributera / trgovca / komisije agent / affiliate / prodavače koji prodaje kompanije proizvoda za proviziju.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +412,{0} against Purchase Order {1},{0} protiv narudzbine dobavljacu {1}
DocType: Patient,Patient Demographics,Demografija pacijenta
DocType: Task,Actual Start Date (via Time Sheet),Stvarni Ozljede Datum (preko Time Sheet)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Ovo je primjer web stranica automatski generira iz ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +55,Ageing Range 1,Starenje Range 1
DocType: Shopify Settings,Enable Shopify,Omogući Shopify
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,Total advance amount cannot be greater than total claimed amount,Ukupan iznos uplate ne može biti veći od ukupne tražene iznose
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.","Standard poreza predložak koji se može primijeniti na sve kupovnih transakcija. Ovaj predložak može sadržavati popis poreskih glava i drugih rashoda glave kao što su ""Shipping"", ""osiguranje"", ""Rukovanje"" itd 

 #### Napomena 

 Stopa poreza te definirati ovdje će biti standardna stopa poreza za sve ** Predmeti **. Ako postoje ** ** Predmeti koji imaju različite stope, oni moraju biti dodan u ** Stavka poreza na stolu ** u ** ** Stavka master.

 #### Opis Kolumne 

 1. Obračun Tip: 
 - To može biti na ** Neto Ukupno ** (to je zbroj osnovnog iznosa).
 - ** Na Prethodna Row Ukupan / Iznos ** (za kumulativni poreza ili naknada). Ako odaberete ovu opciju, porez će se primjenjivati kao postotak prethodnog reda (u tabeli poreza) iznos ili ukupno.
 - ** Stvarna ** (kao što je spomenuto).
 2. Račun Head: The račun knjigu pod kojima porez će biti kažnjen 
 3. Trošak Center: Ako porez / zadužen je prihod (kao što je shipping) ili rashod treba da se rezervirati protiv troška.
 4. Opis: Opis poreza (koje će se štampati u fakturama / navodnika).
 5. Rate: Stopa poreza.
 6. Iznos: Iznos PDV-a.
 7. Ukupno: Kumulativni ukupno do ove tačke.
 8. Unesite Row: Ako na osnovu ""Prethodna Row Ukupno"" možete odabrati broj reda koji se mogu uzeti kao osnova za ovaj proračun (default je prethodnog reda).
 9. Razmislite poreza ili naknada za: U ovom dijelu možete odrediti ako poreski / zadužen je samo za vrednovanje (nije dio od ukupnog broja), ili samo za ukupno (ne dodaje vrijednost u stavku) ili oboje.
 10. Dodavanje ili Oduzeti: Bilo da želite dodati ili oduzeti porez."
DocType: Homepage,Homepage,homepage
DocType: Grant Application,Grant Application Details ,Grant Application Details
DocType: Employee Separation,Employee Separation,Separacija zaposlenih
DocType: BOM Item,Original Item,Original Item
DocType: Purchase Receipt Item,Recd Quantity,RecD Količina
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +170,Doc Date,Doc Date
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +64,Fee Records Created - {0},Naknada Records Kreirano - {0}
DocType: Asset Category Account,Asset Category Account,Asset Kategorija računa
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1017,Row #{0} (Payment Table): Amount must be positive,Red # {0} (Tabela za plaćanje): Iznos mora biti pozitivan
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Ne može proizvesti više predmeta {0} od prodajnog naloga količina {1}
apps/erpnext/erpnext/stock/doctype/item/item.js +440,Select Attribute Values,Odaberite vrijednosti atributa
DocType: Purchase Invoice,Reason For Issuing document,Razlog za izdavanje dokumenta
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +583,Stock Entry {0} is not submitted,Stock upis {0} nije podnesen
DocType: Payment Reconciliation,Bank / Cash Account,Banka / Cash račun
apps/erpnext/erpnext/crm/doctype/lead/lead.py +47,Next Contact By cannot be same as the Lead Email Address,Sljedeća kontaktirati putem ne može biti isti kao Lead-mail adresa
DocType: Tax Rule,Billing City,Billing Grad
DocType: Asset,Manual,priručnik
DocType: Salary Component Account,Salary Component Account,Plaća Komponenta računa
DocType: Global Defaults,Hide Currency Symbol,Sakrij simbol valute
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +281,Sales Opportunities by Source,Mogućnosti prodaje po izvoru
apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informacije o donatorima.
apps/erpnext/erpnext/config/accounts.py +368,"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice"
DocType: Job Applicant,Source Name,izvor ime
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normalni krvni pritisak pri odraslima je oko 120 mmHg sistolnog, a dijastolni 80 mmHg, skraćeni &quot;120/80 mmHg&quot;"
apps/erpnext/erpnext/stock/doctype/batch/batch.py +124,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Postavite rok trajanja u danima, postavite isteku na osnovu production_date plus životni vijek"
DocType: Journal Entry,Credit Note,Kreditne Napomena
DocType: Projects Settings,Ignore Employee Time Overlap,Prezreti vremensko preklapanje radnika
DocType: Warranty Claim,Service Address,Usluga Adresa
DocType: Asset Maintenance Task,Calibration,Kalibracija
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +182,{0} is a company holiday,{0} je praznik kompanije
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py +19,Leave Status Notification,Ostavite obaveštenje o statusu
DocType: Patient Appointment,Procedure Prescription,Procedura Prescription
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +50,Furnitures and Fixtures,Furnitures i raspored
DocType: Travel Request,Travel Type,Tip putovanja
DocType: Item,Manufacture,Proizvodnja
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-YYYY.-
apps/erpnext/erpnext/utilities/user_progress.py +27,Setup Company,Setup Company
,Lab Test Report,Izvještaj o laboratorijskom testu
DocType: Employee Benefit Application,Employee Benefit Application,Aplikacija za zaposlene
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Molimo da Isporuka Note prvi
DocType: Student Applicant,Application Date,patenta
DocType: Salary Component,Amount based on formula,Iznos na osnovu formule
DocType: Purchase Invoice,Currency and Price List,Valuta i cjenik
DocType: Opportunity,Customer / Lead Name,Kupac / Ime osobe koja je Lead
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115,Clearance Date not mentioned,Razmak Datum nije spomenuo
DocType: Payroll Period,Taxable Salary Slabs,Oporezive ploče za oporezivanje
apps/erpnext/erpnext/config/manufacturing.py +7,Production,proizvodnja
DocType: Guardian,Occupation,okupacija
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +210,For Quantity must be less than quantity {0},Količina mora biti manja od količine {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Red {0} : Datum početka mora biti prije datuma završetka
DocType: Salary Component,Max Benefit Amount (Yearly),Maksimalni iznos naknade (godišnji)
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +118,TDS Rate %,TDS Stopa%
DocType: Crop,Planting Area,Sala za sadnju
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Ukupno (Qty)
DocType: Installation Note Item,Installed Qty,Instalirana kol
apps/erpnext/erpnext/utilities/user_progress.py +31,You added ,Dodali ste
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,trening Rezultat
DocType: Purchase Invoice,Is Paid,plaća
DocType: Salary Structure,Total Earning,Ukupna zarada
DocType: Purchase Receipt,Time at which materials were received,Vrijeme u kojem su materijali primili
DocType: Products Settings,Products per Page,Proizvodi po stranici
DocType: Stock Ledger Entry,Outgoing Rate,Odlazni Rate
apps/erpnext/erpnext/controllers/accounts_controller.py +362, or ,ili
DocType: Sales Order,Billing Status,Status naplate
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Prijavi problem
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +127,Utility Expenses,komunalna Troškovi
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,Iznad 90
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +253,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Journal Entry {1} nema nalog {2} ili već usklađeni protiv drugog vaučer
DocType: Supplier Scorecard Criteria,Criteria Weight,Kriterij Težina
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py +7,Leave Approval Notification,Ostavite odobrenje za odobrenje
DocType: Buying Settings,Default Buying Price List,Zadani cjenik kupnje
DocType: Payroll Entry,Salary Slip Based on Timesheet,Plaća za klađenje na Timesheet osnovu
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +49,Buying Rate,Procenat kupovine
apps/erpnext/erpnext/controllers/buying_controller.py +590,Row {0}: Enter location for the asset item {1},Red {0}: Unesite lokaciju za stavku aktive {1}
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
DocType: Company,About the Company,O kompaniji
DocType: Notification Control,Sales Order Message,Poruka narudžbe kupca
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Zadane vrijednosti kao što su tvrtke , valute , tekuće fiskalne godine , itd."
DocType: Payment Entry,Payment Type,Vrsta plaćanja
apps/erpnext/erpnext/stock/doctype/batch/batch.py +245,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Molimo odaberite serijom za Stavka {0}. Nije moguće pronaći jednu seriju koja ispunjava ovaj zahtjev
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.YYYY.-
DocType: Payroll Entry,Select Employees,Odaberite Zaposleni
DocType: Shopify Settings,Sales Invoice Series,Serija faktura prodaje
DocType: Opportunity,Potential Sales Deal,Potencijalni Sales Deal
DocType: Complaint,Complaints,Žalbe
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Izjava o izuzeću poreza na zaposlene
DocType: Payment Entry,Cheque/Reference Date,Ček / Referentni datum
DocType: Purchase Invoice,Total Taxes and Charges,Ukupno Porezi i naknade
apps/erpnext/erpnext/assets/doctype/asset/asset.py +89,Available-for-use Date is entered as past date,Datum dostupan za korišćenje Datum unosi kao prošli datum
DocType: Employee,Emergency Contact,Hitni kontakt
DocType: Bank Reconciliation Detail,Payment Entry,plaćanje Entry
,sales-browser,prodaja-preglednik
apps/erpnext/erpnext/accounts/doctype/account/account.js +78,Ledger,Glavna knjiga
DocType: Drug Prescription,Drug Code,Kodeks o lekovima
DocType: Target Detail,Target  Amount,Ciljani iznos
DocType: POS Profile,Print Format for Online,Format štampe za Online
DocType: Shopping Cart Settings,Shopping Cart Settings,Košarica Settings
DocType: Journal Entry,Accounting Entries,Računovodstvo unosi
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, 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.","Ako je izabrano odredište za cenu &quot;Rate&quot;, on će prepisati cenovnik. Pravilnost cena je konačna stopa, tako da se ne bi trebao koristiti dodatni popust. Stoga, u transakcijama kao što su Prodajni nalog, Narudžbenica i slično, to će biti preuzeto u polju &#39;Rate&#39;, a ne &#39;Polje cijena&#39;."
DocType: Journal Entry,Paid Loan,Paid Loan
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Dupli unos. Provjerite pravila za autorizaciju {0}
DocType: Journal Entry Account,Reference Due Date,Referentni rok za dostavljanje
DocType: Purchase Order,Ref SQ,Ref. SQ
DocType: Leave Type,Applicable After (Working Days),Primenljivo poslije (Radni dani)
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,mora biti dostavljen dokument o prijemu
DocType: Purchase Invoice Item,Received Qty,Pozicija Kol
DocType: Stock Entry Detail,Serial No / Batch,Serijski Ne / Batch
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +351,Not Paid and Not Delivered,Ne plaća i ne dostave
DocType: Product Bundle,Parent Item,Roditelj artikla
DocType: Account,Account Type,Vrsta konta
DocType: Shopify Settings,Webhooks Details,Webhooks Details
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Nema vremena listova
DocType: GoCardless Mandate,GoCardless Customer,GoCardless kupac
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +160,Leave Type {0} cannot be carry-forwarded,Ostavite Tip {0} se ne može nositi-proslijeđen
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',"Raspored održavanja ne stvara za sve stavke . Molimo kliknite na ""Generiraj raspored '"
,To Produce,proizvoditi
DocType: Leave Encashment,Payroll,platni spisak
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +209,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Za red {0} u {1}. Uključiti {2} u tačka stope, redova {3} mora biti uključena"
DocType: Healthcare Service Unit,Parent Service Unit,Jedinica za roditeljsku službu
apps/erpnext/erpnext/utilities/activation.py +101,Make User,Make korisnika
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikacija paketa za dostavu (za tisak)
DocType: Bin,Reserved Quantity,Rezervirano Količina
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Molimo vas da unesete važeću e-mail adresu
DocType: Volunteer Skill,Volunteer Skill,Volonterska vještina
DocType: Bank Reconciliation,Include POS Transactions,Uključite POS transakcije
DocType: Purchase Invoice,Inter Company Invoice Reference,Referenca interne kompanije
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +883,Please select an item in the cart,Molimo izaberite stavku u korpi
DocType: Landed Cost Voucher,Purchase Receipt Items,Primka proizvoda
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Prilagođavanje Obrasci
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +77,Arrear,zaostatak
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Depreciation Amount during the period,Amortizacija Iznos u periodu
DocType: Sales Invoice,Is Return (Credit Note),Je povratak (kreditna beleška)
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +26,Start Job,Započnite posao
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +32,Serial no is required for the asset {0},Serijski broj je potreban za sredstvo {0}
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,predložak invaliditetom ne smije biti zadani predložak
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +290,For row {0}: Enter planned qty,Za red {0}: Unesite planirani broj
DocType: Account,Income Account,Konto prihoda
DocType: Payment Request,Amount in customer's currency,Iznos u valuti kupca
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +880,Delivery,Isporuka
DocType: Volunteer,Weekdays,Radnim danima
DocType: Stock Reconciliation Item,Current Qty,Trenutno Količina
DocType: Restaurant Menu,Restaurant Menu,Restoran meni
apps/erpnext/erpnext/public/js/event.js +23,Add Suppliers,Dodajte dobavljače
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loyalty Program,Help Section,Help Section
apps/erpnext/erpnext/templates/generators/item_group.html +26,Prev,prev
DocType: Appraisal Goal,Key Responsibility Area,Područje odgovornosti
apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Student Paketi pomoći da pratiti prisustvo, procjene i naknade za studente"
DocType: Payment Entry,Total Allocated Amount,Ukupan dodijeljeni iznos
apps/erpnext/erpnext/setup/doctype/company/company.py +163,Set default inventory account for perpetual inventory,Postaviti zadani račun inventar za trajnu inventar
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +261,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
												fullfill Sales Order {2}",Nije moguće dostaviti serijski broj {0} stavke {1} pošto je rezervisan za \ popuniti nalog za prodaju {2}
DocType: Item Reorder,Material Request Type,Materijal Zahtjev Tip
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Pošaljite e-poruku za Grant Review
apps/erpnext/erpnext/accounts/page/pos/pos.js +859,"LocalStorage is full, did not save","LocalStorage je puna, nije spasio"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +130,Row {0}: UOM Conversion Factor is mandatory,Red {0}: UOM Faktor konverzije je obavezno
DocType: Employee Benefit Claim,Claim Date,Datum podnošenja zahtjeva
apps/erpnext/erpnext/utilities/user_progress.py +235,Room Capacity,Kapacitet sobe
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +28,Already record exists for the item {0},Već postoji zapis za stavku {0}
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +28,Ref,Ref.
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +48,You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,Izgubićete podatke o prethodno generisanim računima. Da li ste sigurni da želite ponovo pokrenuti ovu pretplatu?
DocType: Lab Test,LP-,LP-
DocType: Healthcare Settings,Registration Fee,Kotizaciju
DocType: Loyalty Program Collection,Loyalty Program Collection,Zbirka programa lojalnosti
DocType: Stock Entry Detail,Subcontracted Item,Predmet podizvođača
apps/erpnext/erpnext/education/__init__.py +9,Student {0} does not belong to group {1},Student {0} ne pripada grupi {1}
DocType: Budget,Cost Center,Troška
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,Voucher #,bon #
DocType: Notification Control,Purchase Order Message,Poruka narudžbenice
DocType: Tax Rule,Shipping Country,Dostava Country
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Sakriti poreza Id klijenta iz transakcija prodaje
DocType: Upload Attendance,Upload HTML,Prenesi HTML
DocType: Employee,Relieving Date,Rasterećenje Datum
DocType: Purchase Invoice,Total Quantity,Ukupna količina
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.","Cijene Pravilo je napravljen prebrisati Cjenik / definirati postotak popusta, na temelju nekih kriterija."
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladište se može mijenjati samo preko Stock Stupanje / Dostavnica / kupiti primitka
DocType: Employee Education,Class / Percentage,Klasa / Postotak
DocType: Shopify Settings,Shopify Settings,Shopify Settings
DocType: Amazon MWS Settings,Market Place ID,ID tržišta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +122,Head of Marketing and Sales,Voditelj marketinga i prodaje
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Income Tax,Porez na dohodak
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Pratite Potencijalnog kupca prema tip industrije .
apps/erpnext/erpnext/utilities/user_progress.py +101,Go to Letterheads,Idite u Letterheads
DocType: Subscription,Cancel At End Of Period,Otkaži na kraju perioda
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +114,Property already added,Imovina je već dodata
DocType: Item Supplier,Item Supplier,Dobavljač artikla
apps/erpnext/erpnext/public/js/controllers/transaction.js +1322,Please enter Item Code to get batch no,Unesite kod Predmeta da se hrpa nema
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +928,Please select a value for {0} quotation_to {1},Molimo odabir vrijednosti za {0} quotation_to {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +432,No Items selected for transfer,Nije izabrana stavka za prenos
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Sve adrese.
DocType: Company,Stock Settings,Stock Postavke
apps/erpnext/erpnext/accounts/doctype/account/account.py +244,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spajanje je moguće samo ako sljedeće osobine su iste u oba zapisa. Grupa je, Root Tip, Društvo"
DocType: Vehicle,Electric,Electric
DocType: Task,% Progress,% Napredak
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +130,Gain/Loss on Asset Disposal,Dobit / Gubitak imovine Odlaganje
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +24,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",Samo studentski kandidat sa statusom &quot;Odobreno&quot; biće izabran u donjoj tabeli.
DocType: Tax Withholding Category,Rates,Cijene
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +118,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Broj računa za račun {0} nije dostupan. <br> Molimo pravilno podesite svoj račun.
DocType: Task,Depends on Tasks,Ovisi o Zadaci
apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Upravljanje vrstama djelatnosti
DocType: Normal Test Items,Result Value,Vrednost rezultata
DocType: Hotel Room,Hotels,Hoteli
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Novi troška Naziv
DocType: Leave Control Panel,Leave Control Panel,Ostavite Upravljačka ploča
DocType: Project,Task Completion,zadatak Završetak
apps/erpnext/erpnext/templates/includes/product_page.js +31,Not in Stock,Nije raspoloživo
DocType: Volunteer,Volunteer Skills,Volonterske veštine
DocType: Additional Salary,HR User,HR korisnika
DocType: Bank Guarantee,Reference Document Name,Referentni naziv dokumenta
DocType: Purchase Invoice,Taxes and Charges Deducted,Porezi i naknade oduzeti
DocType: Support Settings,Issues,Pitanja
DocType: Loyalty Program,Loyalty Program Name,Ime programa lojalnosti
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status mora biti jedan od {0}
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Podsetnik za ažuriranje GSTIN Poslato
DocType: Sales Invoice,Debit To,Rashodi za
DocType: Restaurant Menu Item,Restaurant Menu Item,Restoran Menu Item
DocType: Delivery Note,Required only for sample item.,Potrebna je samo za primjer stavke.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Stvarna količina nakon transakcije
,Pending SO Items For Purchase Request,Otvorena SO Proizvodi za zahtjev za kupnju
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,student Prijemni
apps/erpnext/erpnext/accounts/party.py +421,{0} {1} is disabled,{0} {1} je onemogućena
DocType: Supplier,Billing Currency,Valuta plaćanja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +175,Extra Large,Ekstra veliki
DocType: Loan,Loan Application,Aplikacija za kredit
DocType: Crop,Scientific Name,Naučno ime
DocType: Healthcare Service Unit,Service Unit Type,Tip jedinice servisne jedinice
DocType: Bank Account,Branch Code,Branch Code
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Leaves,Ukupno Leaves
DocType: Customer,"Reselect, if the chosen contact is edited after save","Ponovo izaberi, ako je odabrani kontakt uređen nakon čuvanja"
DocType: Patient Encounter,In print,U štampi
,Profit and Loss Statement,Račun dobiti i gubitka
DocType: Bank Reconciliation Detail,Cheque Number,Broj čeka
apps/erpnext/erpnext/healthcare/utils.py +264,The item referenced by {0} - {1} is already invoiced,Stavka na koju se odnosi {0} - {1} već je fakturisana
,Sales Browser,prodaja preglednik
DocType: Journal Entry,Total Credit,Ukupna kreditna
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +586,Warning: Another {0} # {1} exists against stock entry {2},Upozorenje: Još {0} {1} # postoji protiv ulaska zaliha {2}
apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Lokalno
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Zajmovi i predujmovi (aktiva)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Dužnici
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +174,Large,Veliki
DocType: Bank Statement Settings,Bank Statement Settings,Postavke banke
DocType: Shopify Settings,Customer Settings,Postavke klijenta
DocType: Homepage Featured Product,Homepage Featured Product,Homepage Istaknuti proizvoda
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +12,View Orders,View Orders
DocType: Marketplace Settings,Marketplace URL (to hide and update label),URL prodavnice (za skrivanje i ažuriranje oznake)
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +229,All Assessment Groups,Sve procjene Grupe
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Novo skladište Ime
DocType: Shopify Settings,App Type,Tip aplikacije
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +384,Total {0} ({1}),Ukupno {0} ({1})
DocType: C-Form Invoice Detail,Territory,Regija
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Molimo spomenuti nema posjeta potrebnih
DocType: Stock Settings,Default Valuation Method,Zadana metoda vrednovanja
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,provizija
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +59,Show Cumulative Amount,Prikaži kumulativni iznos
apps/erpnext/erpnext/setup/doctype/company/company.js +174,Update in progress. It might take a while.,Ažuriranje je u toku. Možda će potrajati neko vrijeme.
DocType: Production Plan Item,Produced Qty,Proizveden količina
DocType: Vehicle Log,Fuel Qty,gorivo Količina
DocType: Stock Entry,Target Warehouse Name,Ime ciljne magacine
DocType: Work Order Operation,Planned Start Time,Planirani Start Time
DocType: Course,Assessment,procjena
DocType: Payment Entry Reference,Allocated,Izdvojena
apps/erpnext/erpnext/config/accounts.py +305,Close Balance Sheet and book Profit or Loss.,Zatvori bilanca i knjiga dobit ili gubitak .
DocType: Student Applicant,Application Status,Primjena Status
DocType: Additional Salary,Salary Component Type,Tip komponenti plata
DocType: Sensitivity Test Items,Sensitivity Test Items,Točke testa osjetljivosti
DocType: Project Update,Project Update,Ažuriranje projekta
DocType: Fees,Fees,naknade
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Odredite Exchange Rate pretvoriti jedne valute u drugu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +164,Quotation {0} is cancelled,Ponuda {0} je otkazana
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +132,Total Outstanding Amount,Ukupno preostali iznos
DocType: Sales Partner,Targets,Mete
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +40,Please register the SIREN number in the company information file,Molimo registrirajte broj SIREN-a u informacijskoj datoteci kompanije
DocType: Email Digest,Sales Orders to Bill,Prodajni nalogi za Bill
DocType: Price List,Price List Master,Cjenik Master
DocType: GST Account,CESS Account,CESS nalog
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Sve Sales Transakcije mogu biti označena protiv više osoba ** ** Sales, tako da možete postaviti i pratiti ciljeve."
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1177,Link to Material Request,Link na zahtev za materijal
apps/erpnext/erpnext/templates/pages/help.html +35,Forum Activity,Aktivnost foruma
,S.O. No.,S.O. Ne.
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Stavka Postavke Transakcije Stavke Bank Banke
apps/erpnext/erpnext/hr/utils.py +158,To date can not greater than employee's relieving date,Do danas ne može biti veći od datuma oslobađanja zaposlenog
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +242,Please create Customer from Lead {0},Kreirajte Kupca iz Poslovne prilike {0}
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Izaberite Pacijent
DocType: Price List,Applicable for Countries,Za zemlje u
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Ime parametra
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +46,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Ostavite samo Prijave sa statusom &quot;Odobreno &#39;i&#39; Odbijena &#39;se može podnijeti
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Student Ime grupe je obavezno u redu {0}
DocType: Homepage,Products to be shown on website homepage,Proizvodi koji će biti prikazan na sajtu homepage
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,To jekorijen skupini kupaca i ne može se mijenjati .
DocType: Student,AB-,AB-
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,Akcija ako je zbirni mesečni budžet prešao na PO
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +249,To Place,Da postavim
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,Revalorizacija deviznog kursa
DocType: POS Profile,Ignore Pricing Rule,Ignorirajte Cijene pravilo
DocType: Employee Education,Graduate,Diplomski
DocType: Leave Block List,Block Days,Blok Dani
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Adresa za dostavu nema zemlju, koja je potrebna za ovo pravilo o otpremi"
DocType: Journal Entry,Excise Entry,Akcizama Entry
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +68,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozorenje: prodajnog naloga {0} već postoji protiv narudžbenice kupca {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.","Standardnim uvjetima koji se mogu dodati da prodaje i kupovine.

 Primjeri: 

 1. Valjanost ponude.
 1. Uslovi plaćanja (unaprijed, na kredit, dio unaprijed itd).
 1. Što je extra (ili na teret kupca).
 1. Sigurnost / Upozorenje korištenje.
 1. Jamstvo ako ih ima.
 1. Vraća politike.
 1. Uvjeti shipping, ako je primjenjivo.
 1. Načini adresiranja sporova, naknadu štete, odgovornosti, itd 
 1. Adresu i kontakt vaše kompanije."
DocType: Issue,Issue Type,Vrsta izdanja
DocType: Attendance,Leave Type,Ostavite Vid
DocType: Purchase Invoice,Supplier Invoice Details,Dobavljač Račun Detalji
DocType: Agriculture Task,Ignore holidays,Ignoriši praznike
apps/erpnext/erpnext/controllers/stock_controller.py +237,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Rashodi / Razlika računa ({0}) mora biti račun 'dobit ili gubitak'
DocType: Project,Copied From,kopira iz
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +253,Invoice already created for all billing hours,Račun je već kreiran za sva vremena plaćanja
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Name error: {0},Ime greška: {0}
DocType: Healthcare Service Unit Type,Item Details,Detalji artikla
DocType: Cash Flow Mapping,Is Finance Cost,Da li je finansijski trošak
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +19,Attendance for employee {0} is already marked,Gledatelja za zaposlenika {0} već označen
DocType: Packing Slip,If more than one package of the same type (for print),Ako je više od jedan paket od iste vrste (za tisak)
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Podesite podrazumevani kupac u podešavanjima restorana
,Salary Register,Plaća Registracija
DocType: Warehouse,Parent Warehouse,Parent Skladište
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +41,Chart,Grafikon
DocType: Subscription,Net Total,Osnovica
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +527,Default BOM not found for Item {0} and Project {1},Uobičajeno sastavnice nije pronađen za Stavka {0} i projekt {1}
apps/erpnext/erpnext/config/non_profit.py +74,Define various loan types,Definirati različite vrste kredita
DocType: Bin,FCFS Rate,FCFS Stopa
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,Izvanredna Iznos
apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Time (u min)
DocType: Project Task,Working,U toku
DocType: Stock Ledger Entry,Stock Queue (FIFO),Kataloški red (FIFO)
apps/erpnext/erpnext/public/js/setup_wizard.js +128,Financial Year,Finansijska godina
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} ne pripada preduzecu {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.,Nije moguće riješiti funkciju rezultata za {0}. Proverite da li je formula validna.
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost as on,Koštaju kao na
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +34,Repayment amount {} should be greater than monthly interest amount {},Iznos otplate {} bi trebao biti veći od mesečnog iznosa kamate {}
DocType: Healthcare Settings,Out Patient Settings,Out Pacijent Settings
DocType: Account,Round Off,Zaokružiti
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +305,Quantity must be positive,Količina mora biti pozitivna
DocType: Material Request Plan Item,Requested Qty,Traženi Kol
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +97,The fields From Shareholder and To Shareholder cannot be blank,Polja Od dioničara i akcionara ne mogu biti prazna
DocType: Cashier Closing,Cashier Closing,Zatvaranje blagajnika
DocType: Tax Rule,Use for Shopping Cart,Koristiti za Košarica
apps/erpnext/erpnext/controllers/item_variant.py +101,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Vrijednost {0} za Atributi {1} ne postoji u listu važećih Stavka Atributi vrijednosti za Stavka {2}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +81,Select Serial Numbers,Odaberite serijski brojevi
DocType: BOM Item,Scrap %,Otpad%
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","Naknade će se distribuirati proporcionalno na osnovu stavka količina ili iznos, po svom izboru"
DocType: Travel Request,Require Full Funding,Zahtevati potpunu finansijsku pomoć
DocType: Maintenance Visit,Purposes,Namjene
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-YYYY.-
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +110,Atleast one item should be entered with negative quantity in return document,Atleast jednu stavku treba upisati s negativnim količine za uzvrat dokumentu
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","Operacija {0} više od bilo koje dostupne radnog vremena u radnu stanicu {1}, razbijaju rad u više operacija"
DocType: Membership,Membership Status,Status članstva
DocType: Travel Itinerary,Lodging Required,Potrebno smeštanje
,Requested,Tražena
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +121,No Remarks,No Napomene
DocType: Asset,In Maintenance,U održavanju
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,Kliknite ovo dugme da biste izveli podatke o prodaji iz Amazon MWS-a.
DocType: Vital Signs,Abdomen,Stomak
DocType: Purchase Invoice,Overdue,Istekao
DocType: Account,Stock Received But Not Billed,Stock primljeni Ali ne Naplaćeno
apps/erpnext/erpnext/accounts/doctype/account/account.py +91,Root Account must be a group,Root račun mora biti grupa
DocType: Drug Prescription,Drug Prescription,Prescription drugs
DocType: Loan,Repaid/Closed,Otplaćen / Closed
DocType: Amazon MWS Settings,CA,CA
DocType: Item,Total Projected Qty,Ukupni planirani Količina
DocType: Monthly Distribution,Distribution Name,Naziv distribucije
apps/erpnext/erpnext/stock/stock_ledger.py +478,"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","Stopa procene nije pronađena za stavku {0}, koja je obavezna da izvrši računovodstvene unose za {1} {2}. Ako je stavka transakcija kao stavka nulte stope procjene u {1}, molimo vas da navedete to u tabeli {1} Item. U suprotnom, molimo vas da kreirate dolaznu transakciju sa akcijama za stavku ili da navedete stopu procene u zapisu Stavke, a zatim pokušajte da podnesete / poništite ovaj unos"
DocType: Course,Course Code,Šifra predmeta
apps/erpnext/erpnext/controllers/stock_controller.py +341,Quality Inspection required for Item {0},Provera kvaliteta potrebna za točke {0}
DocType: Location,Parent Location,Lokacija roditelja
DocType: POS Settings,Use POS in Offline Mode,Koristite POS u Offline načinu
DocType: Supplier Scorecard,Supplier Variables,Dobavljačke varijable
apps/erpnext/erpnext/accounts/page/pos/pos.js +77,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0} je obavezno. Možda evidencija valute ne kreira se za {1} do {2}
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Stopa po kojoj se valuta klijenta se pretvaraju u tvrtke bazne valute
DocType: Purchase Invoice Item,Net Rate (Company Currency),Neto stopa (Company valuta)
DocType: Salary Detail,Condition and Formula Help,Stanje i Formula Pomoć
apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Spisak teritorija - upravljanje.
DocType: Patient Service Unit,Patient Service Unit,Jedinica za pacijentsku službu
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Faktura prodaje
DocType: Journal Entry Account,Party Balance,Party Balance
DocType: Cash Flow Mapper,Section Subtotal,Sekcija subota
apps/erpnext/erpnext/accounts/page/pos/pos.js +500,Please select Apply Discount On,Molimo odaberite Apply popusta na
DocType: Stock Settings,Sample Retention Warehouse,Skladište za zadržavanje uzorka
DocType: Company,Default Receivable Account,Uobičajeno Potraživanja račun
DocType: Purchase Invoice,Deemed Export,Pretpostavljeni izvoz
DocType: Stock Entry,Material Transfer for Manufacture,Prijenos materijala za izradu
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.,Postotak popusta se može neovisno primijeniti prema jednom ili za više cjenika.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +426,Accounting Entry for Stock,Računovodstvo Entry za Stock
DocType: Lab Test,LabTest Approver,LabTest Approver
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Ste već ocijenili za kriterije procjene {}.
DocType: Vehicle Service,Engine Oil,Motorno ulje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1081,Work Orders Created: {0},Objavljeni radni nalogi: {0}
DocType: Sales Invoice,Sales Team1,Prodaja Team1
apps/erpnext/erpnext/stock/doctype/item/item.py +564,Item {0} does not exist,Artikal {0} ne postoji
DocType: Sales Invoice,Customer Address,Kupac Adresa
DocType: Loan,Loan Details,kredit Detalji
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to setup post company fixtures,Nije uspelo postaviti post kompanije
DocType: Company,Default Inventory Account,Uobičajeno zaliha računa
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +193,The folio numbers are not matching,Folio brojevi se ne podudaraju
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +304,Payment Request for {0},Zahtjev za plaćanje za {0}
DocType: Item Barcode,Barcode Type,Tip barkoda
DocType: Antibiotic,Antibiotic Name,Antibiotički naziv
apps/erpnext/erpnext/config/buying.py +43,Supplier Group master.,Glavni tim dobavljača.
DocType: Healthcare Service Unit,Occupancy Status,Status zauzetosti
DocType: Purchase Invoice,Apply Additional Discount On,Nanesite dodatni popust na
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66,Select Type...,Izaberite Tip ...
apps/erpnext/erpnext/templates/pages/help.html +52,Your tickets,Vaše karte
DocType: Account,Root Type,korijen Tip
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558,Close the POS,Zatvorite POS
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +139,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: ne mogu vratiti više od {1} {2} za tačka
DocType: Item Group,Show this slideshow at the top of the page,Prikaži ovaj slideshow na vrhu stranice
DocType: BOM,Item UOM,Mjerna jedinica artikla
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Iznos PDV-a Nakon Popust Iznos (Company valuta)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +252,Target warehouse is mandatory for row {0},Target skladište je obvezno za redom {0}
DocType: Cheque Print Template,Primary Settings,primarni Postavke
DocType: Attendance Request,Work From Home,Radite od kuće
DocType: Purchase Invoice,Select Supplier Address,Izaberite dobavljač adresa
apps/erpnext/erpnext/public/js/event.js +27,Add Employees,Dodaj zaposlenog
DocType: Purchase Invoice Item,Quality Inspection,Provjera kvalitete
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +171,Extra Small,Extra Small
DocType: Company,Standard Template,standard Template
DocType: Training Event,Theory,teorija
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1087,Warning: Material Requested Qty is less than Minimum Order Qty,Upozorenje : Materijal tražena količina manja nego minimalna narudžba kol
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +212,Account {0} is frozen,Konto {0} je zamrznut
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Pravna osoba / Podružnica sa zasebnim kontnom pripadaju Organizacije.
DocType: Payment Request,Mute Email,Mute-mail
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Hrana , piće i duhan"
DocType: Account,Account Number,Broj računa
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +794,Can only make payment against unbilled {0},Mogu samo napraviti uplatu protiv nenaplaćenu {0}
apps/erpnext/erpnext/controllers/selling_controller.py +111,Commission rate cannot be greater than 100,Proviziju ne može biti veća od 100
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Dodjeljivanje unaprijed automatski (FIFO)
DocType: Volunteer,Volunteer,Dobrovoljno
DocType: Buying Settings,Subcontract,Podugovor
apps/erpnext/erpnext/public/js/utils/party.js +167,Please enter {0} first,Unesite {0} prvi
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +103,No replies from,Nema odgovora od
DocType: Work Order Operation,Actual End Time,Stvarni End Time
DocType: Item,Manufacturer Part Number,Proizvođač Broj dijela
DocType: Taxable Salary Slab,Taxable Salary Slab,Oporeziva plata za oporezivanje
DocType: Work Order Operation,Estimated Time and Cost,Procijenjena vremena i troškova
DocType: Bin,Bin,Kanta
DocType: Crop,Crop Name,Naziv žetve
apps/erpnext/erpnext/hub_node/api.py +54,Only users with {0} role can register on Marketplace,Samo korisnici sa ulogom {0} mogu se registrovati na tržištu
DocType: SMS Log,No of Sent SMS,Ne poslanih SMS
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.YYYY.-
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py +8,Appointments and Encounters,Imenovanja i susreti
DocType: Antibiotic,Healthcare Administrator,Administrator zdravstvene zaštite
apps/erpnext/erpnext/utilities/user_progress.py +47,Set a Target,Postavite cilj
DocType: Dosage Strength,Dosage Strength,Snaga doziranja
DocType: Healthcare Practitioner,Inpatient Visit Charge,Hirurška poseta
DocType: Account,Expense Account,Rashodi račun
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Software
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +178,Colour,Boja
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteriji Plan Procjena
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card_dashboard.py +8,Transactions,Transakcije
apps/erpnext/erpnext/stock/doctype/batch/batch.py +123,Expiry date is mandatory for selected item,Datum isteka je obavezan za odabranu stavku
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Sprečite kupovne naloge
apps/erpnext/erpnext/healthcare/setup.py +190,Susceptible,Podložno
DocType: Patient Appointment,Scheduled,Planirano
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Upit za ponudu.
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","Molimo odaberite Stavka u kojoj &quot;Je Stock Stavka&quot; je &quot;ne&quot; i &quot;Da li je prodaja Stavka&quot; je &quot;Da&quot;, a nema drugog Bundle proizvoda"
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Izaberite Kupca
DocType: Student Log,Academic,akademski
DocType: Patient,Personal and Social History,Lična i društvena istorija
apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,User {0} created,Korisnik {0} kreiran
DocType: Fee Schedule,Fee Breakup for each student,Naknada za svaki student
apps/erpnext/erpnext/controllers/accounts_controller.py +601,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupno unaprijed ({0}) protiv Order {1} ne može biti veći od Grand Ukupno ({2})
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Odaberite Mjesečni Distribucija nejednako distribuirati mete širom mjeseci.
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +88,Change Code,Promeni kod
DocType: Purchase Invoice Item,Valuation Rate,Vrednovanje Stopa
DocType: Vehicle,Diesel,dizel
apps/erpnext/erpnext/stock/get_item_details.py +546,Price List Currency not selected,Cjenik valuta ne bira
DocType: Purchase Invoice,Availed ITC Cess,Iskoristio ITC Cess
,Student Monthly Attendance Sheet,Student Mjesečni Posjeta list
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Pravilo o isporuci primenjuje se samo za prodaju
apps/erpnext/erpnext/assets/doctype/asset/asset.py +210,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Redosled amortizacije {0}: Sledeći datum amortizacije ne može biti pre datuma kupovine
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Datum početka Projekta
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +36,Until,Do
DocType: Rename Tool,Rename Log,Preimenovanje Prijavite
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Student Grupe ili Terminski plan je obavezno
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Održavati Billing vrijeme i Radno vrijeme ista na Timesheet
DocType: Maintenance Visit Purpose,Against Document No,Protiv dokumentu nema
DocType: BOM,Scrap,komadić
apps/erpnext/erpnext/utilities/user_progress.py +217,Go to Instructors,Idi na instruktore
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Upravljanje prodajnih partnera.
DocType: Quality Inspection,Inspection Type,Inspekcija Tip
DocType: Fee Validity,Visited yet,Posjećeno još
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134,Warehouses with existing transaction can not be converted to group.,Skladišta sa postojećim transakcija se ne može pretvoriti u grupi.
DocType: Assessment Result Tool,Result HTML,rezultat HTML
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,Koliko često treba ažurirati projekat i kompaniju na osnovu prodajnih transakcija.
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,ističe
apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Dodaj Studenti
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js +18,Please select {0},Odaberite {0}
DocType: C-Form,C-Form No,C-Obrazac br
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +346,Distance,Razdaljina
apps/erpnext/erpnext/utilities/user_progress.py +139,List your products or services that you buy or sell.,Navedite svoje proizvode ili usluge koje kupujete ili prodajete.
DocType: Water Analysis,Storage Temperature,Temperatura skladištenja
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-YYYY.-
DocType: Employee Attendance Tool,Unmarked Attendance,Unmarked Posjeta
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +256,Creating Payment Entries......,Kreiranje unosa za uplate ......
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Researcher,istraživač
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Upis Tool Student
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Datum početka trebalo bi da bude manji od datuma završetka zadatka {0}
,Consolidated Financial Statement,Konsolidovana finansijska izjava
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Ime ili e-obavezno
DocType: Instructor,Instructor Log,Logor instruktora
DocType: Clinical Procedure,Clinical Procedure,Klinička procedura
DocType: Shopify Settings,Delivery Note Series,Serija Napomena o isporuci
DocType: Purchase Order Item,Returned Qty,Vraćeni Količina
DocType: Student,Exit,Izlaz
apps/erpnext/erpnext/accounts/doctype/account/account.py +163,Root Type is mandatory,Korijen Tip je obvezno
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Nije uspela instalirati memorije
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,UOM konverzija u satima
DocType: Contract,Signee Details,Signee Detalji
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} trenutno ima {1} Scorecard stava i RFQs ovog dobavljača treba izdati oprezno.
DocType: Certified Consultant,Non Profit Manager,Neprofitni menadžer
DocType: BOM,Total Cost(Company Currency),Ukupni troškovi (Company Valuta)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +398,Serial No {0} created,Serijski Ne {0} stvorio
DocType: Homepage,Company Description for website homepage,Kompanija Opis za web stranice homepage
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Za praktičnost kupaca, te kodovi mogu se koristiti u tiskanim formata kao što su fakture i otpremnice"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,Suplier ime
apps/erpnext/erpnext/accounts/report/financial_statements.py +175,Could not retrieve information for {0}.,Ne mogu se preuzeti podaci za {0}.
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +138,Opening Entry Journal,Otvaranje časopisa
DocType: Contract,Fulfilment Terms,Uslovi ispunjenja
DocType: Sales Invoice,Time Sheet List,Time Sheet List
DocType: Employee,You can enter any date manually,Možete unijeti bilo koji datum ručno
DocType: Healthcare Settings,Result Printed,Result Printed
DocType: Asset Category Account,Depreciation Expense Account,Troškovi amortizacije računa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +214,Probationary Period,Probni rad
DocType: Purchase Taxes and Charges Template,Is Inter State,Da li je država Inter
apps/erpnext/erpnext/config/hr.py +269,Shift Management,Shift Management
DocType: Customer Group,Only leaf nodes are allowed in transaction,Samo leaf čvorovi su dozvoljeni u transakciji
DocType: Project,Total Costing Amount (via Timesheets),Ukupni iznos troškova (preko Timesheeta)
DocType: Department,Expense Approver,Rashodi Approver
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +168,Row {0}: Advance against Customer must be credit,Red {0}: Advance protiv Klijent mora biti kredit
DocType: Project,Hourly,Po satu
apps/erpnext/erpnext/accounts/doctype/account/account.js +88,Non-Group to Group,Non-grupe do grupe
DocType: Employee,ERPNext User,ERPNext User
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Serija je obavezno u nizu {0}
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Kupnja Prijem artikla Isporuka
DocType: Amazon MWS Settings,Enable Scheduled Synch,Omogućite zakazanu sinhronizaciju
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,To datuma i vremena
apps/erpnext/erpnext/config/selling.py +308,Logs for maintaining sms delivery status,Dnevnici za održavanje sms statusa isporuke
DocType: Accounts Settings,Make Payment via Journal Entry,Izvršiti uplatu preko Journal Entry
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +241,Printed On,otisnut na
DocType: Clinical Procedure Template,Clinical Procedure Template,Obrazac kliničkog postupka
DocType: Item,Inspection Required before Delivery,Inspekcija Potrebna prije isporuke
DocType: Item,Inspection Required before Purchase,Inspekcija Obavezno prije kupnje
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Aktivnosti na čekanju
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js +41,Create Lab Test,Napravite laboratorijski test
DocType: Patient Appointment,Reminded,Podsetio
apps/erpnext/erpnext/public/js/setup_wizard.js +126,View Chart of Accounts,Pregled grafikona računa
DocType: Chapter Member,Chapter Member,Član poglavlja
DocType: Material Request Plan Item,Minimum Order Quantity,Minimalna količina narudžbine
apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Vaša organizacija
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +84,"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}","Preskočite raspodelu raspoređivanja za sledeće zaposlene, jer evidencije o izuzeću već postoje protiv njih. {0}"
DocType: Fee Component,Fees Category,naknade Kategorija
apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,Please enter relieving date.,Unesite olakšavanja datum .
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
DocType: Travel Request,"Details of Sponsor (Name, Location)","Detalji sponzora (ime, lokacija)"
DocType: Supplier Scorecard,Notify Employee,Obavesti zaposlenika
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Unesite naziv kampanje, ako je izvor upit je kampanja"
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,novinski izdavači
apps/erpnext/erpnext/hr/utils.py +154,Future dates not allowed,Dalji datumi nisu dozvoljeni
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Odaberite Fiskalna godina
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Expected Delivery Date should be after Sales Order Date,Očekivani datum isporuke treba da bude nakon datuma prodaje
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Ponovno red Level
DocType: Company,Chart Of Accounts Template,Kontni plan Template
DocType: Attendance,Attendance Date,Gledatelja Datum
apps/erpnext/erpnext/assets/doctype/asset/asset.py +80,Update stock must be enable for the purchase invoice {0},Ažuriranje zaliha mora biti omogućeno za fakturu za kupovinu {0}
apps/erpnext/erpnext/stock/get_item_details.py +405,Item Price updated for {0} in Price List {1},Artikal Cijena ažuriranje za {0} u Cjenik {1}
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Plaća raspada temelju zarađivati i odbitka.
apps/erpnext/erpnext/accounts/doctype/account/account.py +135,Account with child nodes cannot be converted to ledger,Konto sa pod-kontima se ne može pretvoriti u glavnoj knjizi
DocType: Purchase Invoice Item,Accepted Warehouse,Prihvaćeno skladište
DocType: Bank Reconciliation Detail,Posting Date,Objavljivanje Datum
DocType: Item,Valuation Method,Vrednovanje metoda
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +30,One customer can be part of only single Loyalty Program.,Jedan korisnik može biti deo samo jednog programa lojalnosti.
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Half Day
DocType: Sales Invoice,Sales Team,Prodajni tim
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +88,Duplicate entry,Dupli unos
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +19,Enter the name of the Beneficiary before submittting.,Unesite ime Korisnika pre podnošenja.
DocType: Program Enrollment Tool,Get Students,Get Studenti
DocType: Serial No,Under Warranty,Pod jamstvo
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +530,[Error],[Greska]
DocType: Sales Order,In Words will be visible once you save the Sales Order.,U riječi će biti vidljiv nakon što spremite prodajnog naloga.
,Employee Birthday,Rođendani zaposlenih
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Molimo izaberite Datum završetka za završeno popravljanje
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Student Batch Posjeta Tool
apps/erpnext/erpnext/controllers/status_updater.py +216,Limit Crossed,limit Crossed
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Planirani Upto
DocType: Woocommerce Settings,Secret,Tajna
DocType: Company,Date of Establishment,Datum uspostavljanja
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Preduzetnički kapital
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.,Akademski pojam sa ovim &quot;akademska godina&quot; {0} i &#39;Term Ime&#39; {1} već postoji. Molimo vas da mijenjati ove stavke i pokušati ponovo.
DocType: UOM,Must be Whole Number,Mora biti cijeli broj
DocType: Leave Control Panel,New Leaves Allocated (In Days),Novi Lišće alociran (u danima)
DocType: Purchase Invoice,Invoice Copy,Račun Copy
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serijski Ne {0} ne postoji
DocType: Sales Invoice Item,Customer Warehouse (Optional),Customer Warehouse (Opcionalno)
DocType: Blanket Order Item,Blanket Order Item,Stavka narudžbe odeće
DocType: Pricing Rule,Discount Percentage,Postotak rabata
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Rezervisano za podugovaranje
DocType: Payment Reconciliation Invoice,Invoice Number,Račun broj
DocType: Shopping Cart Settings,Orders,Narudžbe
DocType: Travel Request,Event Details,Detalji događaja
DocType: Department,Leave Approver,Ostavite odobravatelju
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +316,Please select a batch,Molimo odaberite serije
apps/erpnext/erpnext/config/hr.py +145,Travel and Expense Claim,Zahtev za putovanja i troškove
DocType: Sales Invoice,Redemption Cost Center,Centar za isplatu troškova
DocType: Assessment Group,Assessment Group Name,Procjena Ime grupe
DocType: Manufacturing Settings,Material Transferred for Manufacture,Materijal za Preneseni Proizvodnja
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +60,Add to Details,Dodaj u Detalji
DocType: Travel Itinerary,Taxi,Taksi
DocType: Shopify Settings,Last Sync Datetime,Last Sync Datetime
DocType: Landed Cost Item,Receipt Document Type,Prijem Document Type
DocType: Daily Work Summary Settings,Select Companies,Izaberite Tvrtke
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +320,Proposal/Price Quote,Predlog / Cjenik cijene
DocType: Antibiotic,Healthcare,Zdravstvena zaštita
DocType: Target Detail,Target Detail,Ciljana Detalj
apps/erpnext/erpnext/stock/doctype/item/item.js +67,Single Variant,Jedinstvena varijanta
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +51,All Jobs,Svi poslovi
DocType: Sales Order,% of materials billed against this Sales Order,% Materijala naplaćeno protiv ovog prodajnog naloga
DocType: Program Enrollment,Mode of Transportation,Način prijevoza
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +65,Period Closing Entry,Period zatvaranja Entry
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72,Select Department...,Izaberite Odeljenje ...
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +40,Cost Center with existing transactions can not be converted to group,Troška s postojećim transakcija ne može se prevesti u skupini
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +376,Amount {0} {1} {2} {3},Broj {0} {1} {2} {3}
DocType: Account,Depreciation,Amortizacija
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +103,The number of shares and the share numbers are inconsistent,Broj akcija i brojevi učešća su nedosljedni
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +50,Supplier(s),Dobavljač (s)
DocType: Employee Attendance Tool,Employee Attendance Tool,Alat za evidenciju dolaznosti radnika
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Kreditni limit
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,Avg. Selling Price List Rate,Avg. Prodajna cijena cena
DocType: Loyalty Program Collection,Collection Factor (=1 LP),Faktor sakupljanja (= 1 LP)
DocType: Additional Salary,Salary Component,Plaća Komponenta
apps/erpnext/erpnext/accounts/utils.py +519,Payment Entries {0} are un-linked,Plaćanje Unosi {0} su un-povezani
DocType: GL Entry,Voucher No,Bon Ne
,Lead Owner Efficiency,Lead Vlasnik efikasnost
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +65,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
				as pro-rata component","Možete tražiti samo iznos od {0}, ostatak iznosa {1} bi trebao biti u aplikaciji \ kao pro-rata komponenta"
DocType: Amazon MWS Settings,Customer Type,Tip kupca
DocType: Compensatory Leave Request,Leave Allocation,Ostavite Raspodjela
DocType: Payment Request,Recipient Message And Payment Details,Primalac poruka i plaćanju
DocType: Support Search Source,Source DocType,Source DocType
apps/erpnext/erpnext/templates/pages/help.html +60,Open a new ticket,Otvorite novu kartu
DocType: Training Event,Trainer Email,trener-mail
DocType: Driver,Transporter,Transporter
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Materijalni Zahtjevi {0} stvorio
DocType: Restaurant Reservation,No of People,Broj ljudi
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Predložak termina ili ugovor.
DocType: Bank Account,Address and Contact,Adresa i kontakt
DocType: Vital Signs,Hyper,Hyper
DocType: Cheque Print Template,Is Account Payable,Je nalog plaćaju
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +304,Stock cannot be updated against Purchase Receipt {0},Stock se ne može ažurirati protiv kupovine Prijem {0}
DocType: Support Settings,Auto close Issue after 7 days,Auto blizu izdanje nakon 7 dana
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +85,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Ostavite se ne može dodijeliti prije {0}, kao odsustvo ravnoteža je već carry-proslijeđen u budućnosti rekord raspodjeli odsustvo {1}"
apps/erpnext/erpnext/accounts/party.py +350,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Napomena: Zbog / Reference Datum premašuje dozvoljeni dana kreditnu kupca {0} dan (a)
apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,student zahtjeva
DocType: Hub Tracked Item,Hub Tracked Item,Hub Gusjen stavka
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL primatelja
DocType: Asset Category Account,Accumulated Depreciation Account,Ispravka vrijednosti računa
DocType: Certified Consultant,Discuss ID,Diskutujte ID
DocType: Stock Settings,Freeze Stock Entries,Zamrzavanje Stock Unosi
DocType: Program Enrollment,Boarding Student,Boarding Student
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +81,Please enable Applicable on Booking Actual Expenses,Molimo omogućite stvarne troškove koji se primjenjuju na osnovu rezervisanja
DocType: Asset Finance Book,Expected Value After Useful Life,Očekivana vrijednost Nakon Korisni Life
DocType: Item,Reorder level based on Warehouse,Nivo Ponovno red zasnovan na Skladište
DocType: Activity Cost,Billing Rate,Billing Rate
,Qty to Deliver,Količina za dovođenje
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,Amazon će sinhronizovati podatke ažurirane nakon ovog datuma
,Stock Analytics,Stock Analytics
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +537,Operations cannot be left blank,Operacije se ne može ostati prazno
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py +72,Lab Test(s) ,Lab Test (i)
DocType: Maintenance Visit Purpose,Against Document Detail No,Protiv dokumenta Detalj No
apps/erpnext/erpnext/regional/__init__.py +11,Deletion is not permitted for country {0},Brisanje nije dozvoljeno za zemlju {0}
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +111,Party Type is mandatory,Party Tip je obavezno
DocType: Quality Inspection,Outgoing,Društven
DocType: Material Request,Requested For,Traženi Za
DocType: Quotation Item,Against Doctype,Protiv DOCTYPE
apps/erpnext/erpnext/controllers/buying_controller.py +491,{0} {1} is cancelled or closed,{0} {1} je otkazan ili zatvoren
DocType: Asset,Calculate Depreciation,Izračunajte amortizaciju
DocType: Delivery Note,Track this Delivery Note against any Project,Prati ovu napomenu o isporuci na svim Projektima
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +89,Net Cash from Investing,Neto novčani tok od investicione
DocType: Work Order,Work-in-Progress Warehouse,Rad u tijeku Warehouse
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +116,Asset {0} must be submitted,Asset {0} mora biti dostavljena
DocType: Fee Schedule Program,Total Students,Ukupno Studenti
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Rekord {0} postoji protiv Student {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +390,Reference #{0} dated {1},Reference # {0} od {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +179,Depreciation Eliminated due to disposal of assets,Amortizacija Eliminisan zbog raspolaganje imovinom
DocType: Employee Transfer,New Employee ID,Novi ID zaposlenih
DocType: Loan,Member,Član
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Upravljanje Adrese
DocType: Work Order Item,Work Order Item,Work Order Item
DocType: Pricing Rule,Item Code,Šifra artikla
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-YYYY.-
DocType: Serial No,Warranty / AMC Details,Jamstveni / AMC Brodu
apps/erpnext/erpnext/education/doctype/student_group/student_group.js +119,Select students manually for the Activity based Group,Izbor studenata ručno za grupe aktivnosti na osnovu
DocType: Journal Entry,User Remark,Upute Zabilješka
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85,Optimizing routes.,Optimizacija ruta.
DocType: Travel Itinerary,Non Diary,Non Dnevnik
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py +14,Cannot create Retention Bonus for left Employees,Ne mogu napraviti bonus zadržavanja za ljevičke zaposlene
DocType: Lead,Market Segment,Tržišni segment
DocType: Agriculture Analysis Criteria,Agriculture Manager,Poljoprivredni menadžer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +999,Paid Amount cannot be greater than total negative outstanding amount {0},Uplaćeni iznos ne može biti veći od ukupnog broja negativnih preostali iznos {0}
DocType: Supplier Scorecard Period,Variables,Varijable
DocType: Employee Internal Work History,Employee Internal Work History,Istorija rada zaposlenog u preduzeću
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +264,Closing (Dr),Zatvaranje (Dr)
DocType: Cheque Print Template,Cheque Size,Ček Veličina
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +284,Serial No {0} not in stock,Serijski Ne {0} nije u dioničko
apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Porezna predložak za prodaju transakcije .
DocType: Sales Invoice,Write Off Outstanding Amount,Otpisati preostali iznos
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Računa {0} ne odgovara Company {1}
DocType: Education Settings,Current Academic Year,Trenutni akademske godine
DocType: Stock Settings,Default Stock UOM,Zadana kataloška mjerna jedinica
DocType: Asset,Number of Depreciations Booked,Broj Amortizacija Booked
apps/erpnext/erpnext/public/js/pos/pos.html +71,Qty Total,Količina Ukupno
DocType: Landed Cost Item,Receipt Document,dokument o prijemu
DocType: Employee Education,School/University,Škola / Univerzitet
DocType: Sales Invoice Item,Available Qty at Warehouse,Dostupna količina na skladištu
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Naplaćeni iznos
DocType: Share Transfer,(including),(uključujući)
DocType: Asset,Double Declining Balance,Double degresivne
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +187,Closed order cannot be cancelled. Unclose to cancel.,Zatvorena kako se ne može otkazati. Otvarati da otkaže.
apps/erpnext/erpnext/config/hr.py +120,Payroll Setup,Podešavanje plata
DocType: Amazon MWS Settings,Synch Products,Synch Products
DocType: Loyalty Point Entry,Loyalty Program,Program lojalnosti
DocType: Student Guardian,Father,otac
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +59,Support Tickets,Podrška ulaznice
apps/erpnext/erpnext/controllers/accounts_controller.py +687,'Update Stock' cannot be checked for fixed asset sale,&#39;Update Stock&#39; ne može se provjeriti na prodaju osnovnih sredstava
DocType: Bank Reconciliation,Bank Reconciliation,Banka pomirenje
DocType: Attendance,On Leave,Na odlasku
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Get Updates
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +97,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Račun {2} ne pripada kompaniji {3}
apps/erpnext/erpnext/stock/doctype/item/item.js +446,Select at least one value from each of the attributes.,Izaberite najmanje jednu vrijednost od svakog atributa.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +164,Material Request {0} is cancelled or stopped,Materijal Zahtjev {0} je otkazan ili zaustavljen
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +219,Dispatch State,Država otpreme
apps/erpnext/erpnext/config/hr.py +399,Leave Management,Ostavite Management
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +17,Groups,Grupe
DocType: Purchase Invoice,Hold Invoice,Držite fakturu
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +37,Please select Employee,Molimo odaberite Employee
DocType: Sales Order,Fully Delivered,Potpuno Isporučeno
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +304,Lower Income,Niži Prihodi
DocType: Restaurant Order Entry,Current Order,Trenutna porudžbina
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +25,Number of serial nos and quantity must be the same,Broj serijskog broja i količina mora biti isti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +271,Source and target warehouse cannot be same for row {0},Izvor i ciljna skladište ne može biti isti za redom {0}
DocType: Account,Asset Received But Not Billed,Imovina je primljena ali nije fakturisana
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +244,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Razlika račun mora biti tip imovine / odgovornošću obzir, jer je to Stock Pomirenje je otvor za ulaz"
apps/erpnext/erpnext/hr/doctype/loan/loan.py +116,Disbursed Amount cannot be greater than Loan Amount {0},Isplaćeni iznos ne može biti veći od Iznos kredita {0}
apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Programs,Idi na programe
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Red {0} # Raspodijeljena količina {1} ne može biti veća od nezadovoljne količine {2}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +91,Purchase Order number required for Item {0},Broj narudžbenice kupnje je potreban za artikal {0}
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',"' Od datuma ' mora biti poslije ' Do datuma"""
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js +32,No Staffing Plans found for this Designation,Nije pronađeno planiranje kadrova za ovu oznaku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1075,Batch {0} of Item {1} is disabled.,Batch {0} elementa {1} je onemogućen.
DocType: Leave Policy Detail,Annual Allocation,Godišnja dodjela
DocType: Travel Request,Address of Organizer,Adresa organizatora
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68,Select Healthcare Practitioner...,Izaberite zdravstvenu praksu ...
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,Primenjuje se u slučaju Employee Onboarding
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Ne može promijeniti status studenta {0} je povezana s primjenom student {1}
DocType: Asset,Fully Depreciated,potpuno je oslabio
DocType: Item Barcode,UPC-A,UPC-A
,Stock Projected Qty,Projektovana kolicina na zalihama
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +515,Customer {0} does not belong to project {1},Kupac {0} ne pripada projektu {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Označena Posjećenost HTML
apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Citati su prijedlozi, ponude koje ste poslali svojim kupcima"
DocType: Sales Invoice,Customer's Purchase Order,Narudžbenica kupca
DocType: Clinical Procedure,Patient,Pacijent
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +49,Bypass credit check at Sales Order ,Provjerite kreditnu obavezu na nalogu za prodaju
DocType: Employee Onboarding Activity,Employee Onboarding Activity,Aktivnost aktivnosti na radnom mjestu
DocType: Location,Check if it is a hydroponic unit,Proverite da li je to hidroponska jedinica
apps/erpnext/erpnext/config/stock.py +112,Serial No and Batch,Serijski broj i Batch
DocType: Warranty Claim,From Company,Iz Društva
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Zbir desetine Kriteriji procjene treba da bude {0}.
apps/erpnext/erpnext/assets/doctype/asset/asset.py +198,Please set Number of Depreciations Booked,Molimo podesite Broj Amortizacija Booked
DocType: Supplier Scorecard Period,Calculations,Izračunavanje
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86,Value or Qty,"Vrijednost, ili kol"
DocType: Payment Terms Template,Payment Terms,Uslovi plaćanja
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +470,Productions Orders cannot be raised for:,Productions naloga ne može biti podignuta za:
apps/erpnext/erpnext/utilities/user_progress.py +147,Minute,Minuta
DocType: Purchase Invoice,Purchase Taxes and Charges,Kupnja Porezi i naknade
DocType: Chapter,Meetup Embed HTML,Upoznajte Embed HTML
DocType: Asset,Insured value,Osigurana vrijednost
apps/erpnext/erpnext/utilities/user_progress.py +121,Go to Suppliers,Idite na dobavljače
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,POS Closing Voucher Taxes
,Qty to Receive,Količina za primanje
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +564,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Datumi početka i kraja koji nisu u važećem periodu zarada, ne mogu se izračunati {0}."
DocType: Leave Block List,Leave Block List Allowed,Ostavite Block List dopuštenih
DocType: Grading Scale Interval,Grading Scale Interval,Pravilo Scale Interval
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Rashodi Preuzmi za putnom {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Popust (%) na Cjenovnik objekta sa margina
DocType: Healthcare Service Unit Type,Rate / UOM,Rate / UOM
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Svi Skladišta
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1296,No {0} found for Inter Company Transactions.,Nije pronađeno {0} za Inter Company Transactions.
DocType: Travel Itinerary,Rented Car,Iznajmljen automobil
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js +15,About your Company,O vašoj Kompaniji
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +143,Credit To account must be a Balance Sheet account,Kredit na račun mora biti bilans stanja računa
DocType: Donor,Donor,Donor
DocType: Global Defaults,Disable In Words,Onemogućena u Words
apps/erpnext/erpnext/stock/doctype/item/item.py +70,Item Code is mandatory because Item is not automatically numbered,Kod artikla je obvezan jer artikli nisu automatski numerirani
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +101,Quotation {0} not of type {1},Ponuda {0} nije tip {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Raspored održavanja stavki
DocType: Sales Order,%  Delivered,Isporučeno%
apps/erpnext/erpnext/education/doctype/fees/fees.js +108,Please set the Email ID for the Student to send the Payment Request,Molimo da podesite Email ID za Student da pošaljete Zahtev za plaćanje
DocType: Patient,Medical History,Medicinska istorija
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +167,Bank Overdraft Account,Bank Prekoračenje računa
DocType: Patient,Patient ID,ID pacijenta
DocType: Practitioner Schedule,Schedule Name,Ime rasporeda
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +302,Sales Pipeline by Stage,Prodajni gasovod po Stazi
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +49,Make Salary Slip,Provjerite plaće slip
DocType: Currency Exchange,For Buying,Za kupovinu
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +890,Add All Suppliers,Dodajte sve dobavljače
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +95,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: dodijeljeni iznos ne može biti veći od preostalog iznosa.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +84,Browse BOM,Browse BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +165,Secured Loans,osigurani krediti
DocType: Purchase Invoice,Edit Posting Date and Time,Edit knjiženja datuma i vremena
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +106,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Molimo podesite Računi se odnose amortizacije u Asset Kategorija {0} ili kompanije {1}
DocType: Lab Test Groups,Normal Range,Normalni opseg
DocType: Academic Term,Academic Year,akademska godina
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +79,Available Selling,Dostupna prodaja
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,Povlačenje ulazne točke na lojalnost
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +179,Opening Balance Equity,Početno stanje Equity
DocType: Contract,CRM,CRM
DocType: Purchase Invoice,N,N
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,ostali
DocType: Appraisal,Appraisal,Procjena
DocType: Loan,Loan Account,Račun zajma
DocType: Purchase Invoice,GST Details,Detalji GST
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py +6,This is based on transactions against this Healthcare Practitioner.,Ovo se zasniva na transakcijama protiv ovog zdravstvenog lekara.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,Email sent to supplier {0},E-mail poslati na dobavljač {0}
DocType: Item,Default Sales Unit of Measure,Podrazumevana jedinica prodaje mjere
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +12,Academic Year: ,Akademska godina:
DocType: Inpatient Record,Admission Schedule Date,Datum prijema prijave
DocType: Subscription,Past Due Date,Datum prošlosti
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py +19,Not allow to set alternative item for the item {0},Ne dozvolite postavljanje alternativne stavke za stavku {0}
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Datum se ponavlja
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Ovlašteni potpisnik
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +65,Create Fees,Kreiraj naknade
DocType: Project,Total Purchase Cost (via Purchase Invoice),Ukupno TROŠKA (preko fakturi)
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +549,Select Quantity,Odaberite Količina
DocType: Loyalty Point Entry,Loyalty Points,Točke lojalnosti
DocType: Customs Tariff Number,Customs Tariff Number,Carinski tarifni broj
DocType: Patient Appointment,Patient Appointment,Imenovanje pacijenta
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Odobravanje ulogu ne mogu biti isti kao i ulogepravilo odnosi se na
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +65,Unsubscribe from this Email Digest,Odjavili od ovog mail Digest
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +880,Get Suppliers By,Uzmite dobavljača
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +182,{0} not found for Item {1},{0} nije pronađen za stavku {1}
apps/erpnext/erpnext/utilities/user_progress.py +197,Go to Courses,Idi na kurseve
DocType: Accounts Settings,Show Inclusive Tax In Print,Prikaži inkluzivni porez u štampi
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory","Bankarski račun, od datuma i do datuma je obavezan"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +29,Message Sent,Poruka je poslana
apps/erpnext/erpnext/accounts/doctype/account/account.py +105,Account with child nodes cannot be set as ledger,Račun s djetetom čvorovi se ne može postaviti kao glavnu knjigu
DocType: C-Form,II,II
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Stopa po kojoj Cjenik valute se pretvaraju u kupca osnovne valute
DocType: Purchase Invoice Item,Net Amount (Company Currency),Neto iznos (Company valuta)
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +222,Total advance amount cannot be greater than total sanctioned amount,Ukupan iznos avansa ne može biti veći od ukupnog sankcionisanog iznosa
DocType: Salary Slip,Hour Rate,Cijena sata
DocType: Stock Settings,Item Naming By,Artikal imenovan po
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Drugi period Zatvaranje Stupanje {0} je postignut nakon {1}
DocType: Work Order,Material Transferred for Manufacturing,Materijal Prebačen za izradu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +49,Account {0} does not exists,Račun {0} ne postoji
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1604,Select Loyalty Program,Odaberite Loyalty Program
DocType: Project,Project Type,Vrsta projekta
apps/erpnext/erpnext/projects/doctype/task/task.py +154,Child Task exists for this Task. You can not delete this Task.,Zadatak za djecu postoji za ovaj zadatak. Ne možete da izbrišete ovaj zadatak.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +17,Either target qty or target amount is mandatory.,Ili meta Količina ili ciljani iznos je obavezna .
apps/erpnext/erpnext/config/projects.py +56,Cost of various activities,Troškova različitih aktivnosti
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}","Postavljanje Događanja u {0}, jer zaposleni u prilogu ispod prodaje osoba nema korisniku ID {1}"
DocType: Timesheet,Billing Details,Billing Detalji
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163,Source and target warehouse must be different,Izvor i meta skladište mora biti drugačiji
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140,Payment Failed. Please check your GoCardless Account for more details,Plaćanje nije uspelo. Molimo provjerite svoj GoCardless račun za više detalja
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Nije dopušteno osvježavanje burzovnih transakcija stariji od {0}
DocType: BOM,Inspection Required,Inspekcija Obvezno
DocType: Purchase Invoice Item,PR Detail,PR Detalj
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +17,Enter the Bank Guarantee Number before submittting.,Unesite broj garancije banke pre podnošenja.
DocType: Driving License Category,Class,Klasa
DocType: Sales Order,Fully Billed,Potpuno Naplaćeno
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +387,Work Order cannot be raised against a Item Template,Nalog za rad ne može se pokrenuti protiv šablona za stavke
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Pravilo o isporuci primenjivo samo za kupovinu
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Novac u blagajni
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +142,Delivery warehouse required for stock item {0},Isporuka skladište potrebno za zaliha stavku {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Bruto težina paketa. Obično neto težina + ambalaža težina. (Za tisak)
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,Korisnici s ovom ulogom smiju postaviti zamrznute račune i izradu / izmjenu računovodstvenih unosa protiv zamrznutih računa
DocType: Vital Signs,Cuts,Rezanja
DocType: Serial No,Is Cancelled,Je otkazan
DocType: Student Group,Group Based On,Grupa na osnovu
DocType: Journal Entry,Bill Date,Datum računa
DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratorijski SMS upozorenja
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Servis proizvoda, tip, frekvencija i iznos trošak su potrebne"
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:","Čak i ako postoji više Cijene pravila s najvišim prioritetom, onda sljedeći interni prioriteti primjenjuje se:"
DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kriterijumi za analizu biljaka
DocType: Cheque Print Template,Cheque Height,Ček Visina
DocType: Supplier,Supplier Details,Dobavljač Detalji
DocType: Setup Progress,Setup Progress,Napredak podešavanja
DocType: Expense Claim,Approval Status,Status odobrenja
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},Od vrijednosti mora biti manje nego vrijednosti u redu {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +158,Wire Transfer,Wire Transfer
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +93,Check all,Provjerite sve
,Issued Items Against Work Order,Izdate stavke protiv radnog naloga
,BOM Stock Calculated,Obračun BOM-a
DocType: Vehicle Log,Invoice Ref,Račun Ref
DocType: Company,Default Income Account,Zadani račun prihoda
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Vrsta djelatnosti Kupaca / Kupci
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +39,Unclosed Fiscal Years Profit / Loss (Credit),Neriješeni fiskalne godine dobit / gubitak (kredit)
DocType: Sales Invoice,Time Sheets,Time listovi
DocType: Healthcare Service Unit Type,Change In Item,Promenite stavku
DocType: Payment Gateway Account,Default Payment Request Message,Uobičajeno plaćanje poruka zahtjeva
DocType: Retention Bonus,Bonus Amount,Bonus Količina
DocType: Item Group,Check this if you want to show in website,Označite ovo ako želite pokazati u web
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +371,Balance ({0}),Balans ({0})
DocType: Loyalty Point Entry,Redeem Against,Iskoristi protiv
apps/erpnext/erpnext/config/accounts.py +157,Banking and Payments,Bankarstvo i platni promet
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +99,Please enter API Consumer Key,Molimo unesite API korisnički ključ
,Welcome to ERPNext,Dobrodošli na ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Potencijalni kupac do ponude
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,Email podsetnici će biti poslati svim stranama sa kontaktima e-pošte
DocType: Project,Twice Daily,Twice Daily
DocType: Inpatient Record,A Negative,Negativan
apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Ništa više pokazati.
DocType: Lead,From Customer,Od kupca
apps/erpnext/erpnext/demo/setup/setup_data.py +321,Calls,Pozivi
apps/erpnext/erpnext/utilities/user_progress.py +143,A Product,A Product
DocType: Employee Tax Exemption Declaration,Declarations,Deklaracije
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +235,Batches,serija
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Napravite raspored naknada
DocType: Purchase Order Item Supplied,Stock UOM,Kataloški UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +261,Purchase Order {0} is not submitted,Narudžbenicu {0} nije podnesen
DocType: Account,Expenses Included In Asset Valuation,Uključeni troškovi u procenu aktive
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normalni referentni opseg za odraslu osobu je 16-20 diha / minut (RCP 2012)
DocType: Customs Tariff Number,Tariff Number,tarifni broj
DocType: Work Order Item,Available Qty at WIP Warehouse,Dostupno Količina u WIP Skladište
apps/erpnext/erpnext/stock/doctype/item/item.js +41,Projected,Projektovan
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +233,Serial No {0} does not belong to Warehouse {1},Serijski Ne {0} ne pripada Warehouse {1}
apps/erpnext/erpnext/controllers/status_updater.py +180,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Napomena : Sustav neće provjeravati pretjerano isporuke i više - booking za točku {0} kao količinu ili vrijednost je 0
DocType: Notification Control,Quotation Message,Ponuda - poruka
DocType: Issue,Opening Date,Otvaranje Datum
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +89,Please save the patient first,Molim vas prvo sačuvajte pacijenta
apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Posjećenost je uspješno označen.
DocType: Program Enrollment,Public Transport,Javni prijevoz
DocType: Delivery Note,GST Vehicle Type,Tip vozila GST
DocType: Soil Texture,Silt Composition (%),Silt sastav (%)
DocType: Journal Entry,Remark,Primjedba
DocType: Healthcare Settings,Avoid Confirmation,Izbjegavajte potvrdu
DocType: Purchase Receipt Item,Rate and Amount,Kamatna stopa i iznos
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +177,Account Type for {0} must be {1},Tip naloga za {0} mora biti {1}
apps/erpnext/erpnext/config/hr.py +34,Leaves and Holiday,Lišće i privatnom
DocType: Education Settings,Current Academic Term,Trenutni Academic Term
DocType: Sales Order,Not Billed,Ne Naplaćeno
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76,Both Warehouse must belong to same Company,Oba skladišta moraju pripadati istom preduzeću
DocType: Employee Grade,Default Leave Policy,Default Leave Policy
DocType: Shopify Settings,Shop URL,URL prodavnice
apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Još nema ni jednog unijetog kontakta.
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Sleteo Cost vaučera Iznos
,Item Balance (Simple),Balans predmeta (Jednostavno)
apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Mjenice podigao dobavljače.
DocType: POS Profile,Write Off Account,Napišite Off račun
DocType: Patient Appointment,Get prescribed procedures,Provjerite propisane procedure
DocType: Sales Invoice,Redemption Account,Račun za otkup
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +233,Debit Note Amt,Debit note Amt
DocType: Purchase Invoice Item,Discount Amount,Iznos rabata
DocType: Purchase Invoice,Return Against Purchase Invoice,Vratiti protiv fakturi
DocType: Item,Warranty Period (in days),Jamstveni period (u danima)
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Failed to set defaults,Nije uspelo postaviti podrazumevane vrednosti
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Odnos sa Guardian1
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +865,Please select BOM against item {0},Izaberite BOM protiv stavke {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Napravite fakture
DocType: Shopping Cart Settings,Show Stock Quantity,Show Stock Quantity
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +77,Net Cash from Operations,Neto novčani tok od operacije
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Stavka 4
DocType: Student Admission,Admission End Date,Prijem Završni datum
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Podugovaranje
DocType: Journal Entry Account,Journal Entry Account,Journal Entry račun
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,student Group
DocType: Shopping Cart Settings,Quotation Series,Citat serije
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +60,"An item exists with same name ({0}), please change the item group name or rename the item","Stavka postoji s istim imenom ( {0} ) , molimo promijenite ime stavku grupe ili preimenovati stavku"
DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriterijumi za analizu zemljišta
apps/erpnext/erpnext/accounts/page/pos/pos.js +2052,Please select customer,Molimo odaberite kupac
DocType: C-Form,I,ja
DocType: Company,Asset Depreciation Cost Center,Asset Amortizacija troškova Center
DocType: Production Plan Sales Order,Sales Order Date,Datum narudžbe kupca
DocType: Sales Invoice Item,Delivered Qty,Isporučena količina
DocType: Assessment Plan,Assessment Plan,plan procjene
DocType: Travel Request,Fully Sponsored,Fully Sponsored
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +28,Reverse Journal Entry,Povratni dnevnik
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Klijent {0} je kreiran.
DocType: Stock Settings,Limit Percent,limit Procenat
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Trenutno nema dostupnih trgovina na zalihama
,Payment Period Based On Invoice Date,Razdoblje za naplatu po Datum fakture
DocType: Sample Collection,No. of print,Broj otiska
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Hotelska rezervacija Stavka
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +59,Missing Currency Exchange Rates for {0},Nedostaje Valuta Tečaj za {0}
DocType: Employee Health Insurance,Health Insurance Name,Naziv zdravstvenog osiguranja
DocType: Assessment Plan,Examiner,ispitivač
DocType: Student,Siblings,braća i sestre
DocType: Journal Entry,Stock Entry,Kataloški Stupanje
DocType: Payment Entry,Payment References,plaćanje Reference
DocType: Subscription Plan,"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days","Broj intervala za intervalno polje npr. Ako je Interval &quot;Dani&quot; i broj intervala obračuna je 3, fakture će biti generirane svakih 3 dana"
DocType: Clinical Procedure Template,Allow Stock Consumption,Dozvolite potrošnju zaliha
DocType: Asset,Insurance Details,osiguranje Detalji
DocType: Account,Payable,Plativ
DocType: Share Balance,Share Type,Tip deljenja
apps/erpnext/erpnext/hr/doctype/loan/loan.py +123,Please enter Repayment Periods,Unesite rokovi otplate
apps/erpnext/erpnext/shopping_cart/cart.py +378,Debtors ({0}),Dužnici ({0})
DocType: Pricing Rule,Margin,Marža
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Novi Kupci
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Gross Profit %,Bruto dobit%
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +90,Appointment {0} and Sales Invoice {1} cancelled,Imenovanje {0} i faktura za prodaju {1} otkazana
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +43,Opportunities by lead source,Mogućnosti izvora izvora
DocType: Appraisal Goal,Weightage (%),Weightage (%)
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +555,Change POS Profile,Promenite POS profil
DocType: Bank Reconciliation Detail,Clearance Date,Razmak Datum
DocType: Delivery Settings,Dispatch Notification Template,Šablon za obavještenje o otpremi
apps/erpnext/erpnext/stock/doctype/item/item.py +722,"Asset is already exists against the item {0}, you cannot change the has serial no value","Asset već postoji protiv stavke {0}, ne možete promeniti serijsku vrijednost"
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Report,Izveštaj o proceni
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +26,Get Employees,Dobijte zaposlene
apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Gross Purchase Amount is mandatory,Bruto Kupovina Iznos je obavezno
apps/erpnext/erpnext/setup/doctype/company/company.js +115,Company name not same,Ime kompanije nije isto
DocType: Lead,Address Desc,Adresa silazno
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +114,Party is mandatory,Party je obavezno
DocType: Topic,Topic Name,Topic Name
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +312,Please set default template for Leave Approval Notification in HR Settings.,Molimo postavite podrazumevani obrazac za obavještenje o odobrenju odobrenja u HR postavkama.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +38,Atleast one of the Selling or Buying must be selected,Barem jedan od prodajete ili kupujete mora biti odabran
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +308,Select an employee to get the employee advance.,Izaberi zaposlenog da unapredi radnika.
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,Izaberite važeći datum
apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Odaberite priroda vašeg poslovanja.
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.","Pojedinačni za rezultate koji zahtevaju samo jedan ulaz, rezultat UOM i normalna vrijednost <br> Jedinjenje za rezultate koji zahtevaju više polja za unos sa odgovarajućim imenima događaja, rezultatima UOM-a i normalnim vrednostima <br> Deskriptivno za testove koji imaju više komponenti rezultata i odgovarajuće polja za unos rezultata. <br> Grupisani za test šablone koji su grupa drugih test šablona. <br> Nema rezultata za testove bez rezultata. Takođe, nije napravljen nikakav laboratorijski test. npr. Sub testovi za grupisane rezultate."
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +87,Row #{0}: Duplicate entry in References {1} {2},Row # {0}: duplikat unosa u Reference {1} {2}
apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Gdje se obavljaju proizvodne operacije.
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +39,As Examiner,Kao ispitivač
DocType: Company,Default Expense Claim Payable Account,Podrazumevani troškovi potraživanja
DocType: Appointment Type,Default Duration,Default Duration
DocType: BOM Explosion Item,Source Warehouse,Izvorno skladište
DocType: Installation Note,Installation Date,Instalacija Datum
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Share Ledger
apps/erpnext/erpnext/controllers/accounts_controller.py +661,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} ne pripada kompaniji {2}
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +114,Sales Invoice {0} created,Prodajna faktura {0} kreirana
DocType: Employee,Confirmation Date,potvrda Datum
DocType: Inpatient Occupancy,Check Out,Provjeri
DocType: C-Form,Total Invoiced Amount,Ukupno Iznos dostavnice
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +51,Min Qty can not be greater than Max Qty,Min Kol ne može biti veći od Max Kol
DocType: Soil Texture,Silty Clay,Silty Clay
DocType: Account,Accumulated Depreciation,Akumuliranu amortizaciju
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stalno ime
DocType: Stock Entry,Customer or Supplier Details,Detalji o Kupcu ili Dobavljacu
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Asset Value Adjustment,Current Asset Value,Trenutna vrednost aktive
DocType: Travel Request,Travel Funding,Finansiranje putovanja
DocType: Loan Application,Required by Date,Potreban po datumu
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,Veza sa svim lokacijama u kojima se Crop raste
DocType: Lead,Lead Owner,Vlasnik Lead-a
DocType: Production Plan,Sales Orders Detail,Prodajna narudžbina Detail
DocType: Bin,Requested Quantity,Tražena količina
DocType: Fees,EDU-FEE-.YYYY.-,EDU-FEE-.YYYY.-
DocType: Patient,Marital Status,Bračni status
DocType: Stock Settings,Auto Material Request,Auto Materijal Zahtjev
DocType: Woocommerce Settings,API consumer secret,API potrošačke tajne
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Dostupno Batch Količina na Od Skladište
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Bruto Pay - Ukupno odbitak - Otplata kredita
DocType: Bank Account,IBAN,IBAN
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +39,Current BOM and New BOM can not be same,Trenutni troškovnik i novi troškovnik ne mogu biti isti
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47,Salary Slip ID,Plaća Slip ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py +128,Date Of Retirement must be greater than Date of Joining,Datum umirovljenja mora biti veći od datuma pristupa
apps/erpnext/erpnext/stock/doctype/item/item.js +70,Multiple Variants,Višestruke varijante
DocType: Sales Invoice,Against Income Account,Protiv računu dohotka
apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Isporučeno
DocType: Subscription,Trial Period Start Date,Datum početka probnog perioda
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +106,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Stavka {0}: {1} Naručena količina ne može biti manji od minimalnog bi Količina {2} (iz točke).
DocType: Certification Application,Certified,Certified
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Mjesečni Distribucija Postotak
DocType: Daily Work Summary Group User,Daily Work Summary Group User,Dnevni posjetilac rezimea
DocType: Territory,Territory Targets,Teritorij Mete
DocType: Soil Analysis,Ca/Mg,Ca / Mg
DocType: Delivery Note,Transporter Info,Transporter Info
apps/erpnext/erpnext/accounts/utils.py +526,Please set default {0} in Company {1},Molimo podesite default {0} u kompaniji {1}
DocType: Cheque Print Template,Starting position from top edge,Početne pozicije od gornje ivice
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33,Same supplier has been entered multiple times,Istog dobavljača je ušao više puta
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Bruto dobit / gubitak
,Warehouse wise Item Balance Age and Value,Skladno mudro Stavka Balansno doba i vrijednost
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Narudžbenica artikla Isporuka
apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Kompanija Ime ne može biti poduzeća
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Zaglavlja za ispis predložaka.
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Naslovi za ispis predložaka pr Predračuna.
DocType: Program Enrollment,Walking,hodanje
DocType: Student Guardian,Student Guardian,student Guardian
DocType: Member,Member Name,Ime člana
DocType: Stock Settings,Use Naming Series,Koristite nazive serije
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +231,Valuation type charges can not marked as Inclusive,Prijava tip vrednovanja ne može označiti kao Inclusive
DocType: POS Profile,Update Stock,Ažurirajte Stock
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.,Različite mjerne jedinice proizvoda će dovesti do ukupne pogrešne neto težine. Budite sigurni da je neto težina svakog proizvoda u istoj mjernoj jedinici.
DocType: Certification Application,Payment Details,Detalji plaćanja
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +41,BOM Rate,BOM Rate
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +249,"Stopped Work Order cannot be cancelled, Unstop it first to cancel","Prekinuto radno porudžbanje ne može se otkazati, Unstop prvi da otkaže"
DocType: Asset,Journal Entry for Scrap,Journal Entry za otpad
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Molimo povucite stavke iz Dostavnica
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +242,Row {0}: select the workstation against the operation {1},Red {0}: izaberite radnu stanicu protiv operacije {1}
apps/erpnext/erpnext/accounts/utils.py +496,Journal Entries {0} are un-linked,Journal unosi {0} su un-povezani
apps/erpnext/erpnext/accounts/utils.py +825,{0} Number {1} already used in account {2},{0} Broj {1} već se koristi na računu {2}
apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Snimak svih komunikacija tipa e-mail, telefon, chat, itd"
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Postupak Scorecard Scoreing Standing
DocType: Manufacturer,Manufacturers used in Items,Proizvođači se koriste u Predmeti
apps/erpnext/erpnext/accounts/general_ledger.py +181,Please mention Round Off Cost Center in Company,Navedite zaokružimo troškova centar u Company
DocType: Purchase Invoice,Terms,Uvjeti
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +10,Select Days,Izaberite Dani
DocType: Academic Term,Term Name,term ime
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +365,Credit ({0}),Kredit ({0})
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +499,Creating Salary Slips...,Kreiranje plata ...
apps/erpnext/erpnext/hr/doctype/department/department.js +14,You cannot edit root node.,Ne možete uređivati root čvor.
DocType: Buying Settings,Purchase Order Required,Narudžbenica kupnje je obavezna
apps/erpnext/erpnext/public/js/projects/timer.js +5,Timer,Tajmer
,Item-wise Sales History,Stavka-mudar Prodaja Povijest
DocType: Expense Claim,Total Sanctioned Amount,Ukupno kažnjeni Iznos
,Purchase Analytics,Kupnja Analytics
DocType: Sales Invoice Item,Delivery Note Item,Stavka otpremnice
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +363,Current invoice {0} is missing,Nedostaje trenutna faktura {0}
DocType: Asset Maintenance Log,Task,Zadatak
DocType: Purchase Taxes and Charges,Reference Row #,Reference Row #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Batch broj je obavezno za Stavka {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +22,This is a root sales person and cannot be edited.,To jekorijen prodavač i ne može se mijenjati .
DocType: Salary Component,"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. ","Ukoliko bude izabran, vrijednost navedene ili izračunata u ovoj komponenti neće doprinijeti zaradu ili odbitaka. Međutim, to je vrijednost se može referencirati druge komponente koje se mogu dodati ili oduzeti."
DocType: Asset Settings,Number of Days in Fiscal Year,Broj dana u fiskalnoj godini
,Stock Ledger,Stock Ledger
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Stopa: {0}
DocType: Company,Exchange Gain / Loss Account,Exchange dobitak / gubitak računa
DocType: Amazon MWS Settings,MWS Credentials,MVS akreditivi
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Zaposleni i dolaznost
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +123,Purpose must be one of {0},Svrha mora biti jedan od {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +99,Fill the form and save it,Ispunite obrazac i spremite ga
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Community Forum
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Stvarne Količina na lageru
DocType: Homepage,"URL for ""All Products""",URL za &quot;Svi proizvodi&quot;
DocType: Leave Application,Leave Balance Before Application,Ostavite Balance Prije primjene
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +41,Send SMS,Pošalji SMS
DocType: Supplier Scorecard Criteria,Max Score,Max Score
DocType: Cheque Print Template,Width of amount in word,Širina iznos u riječi
DocType: Company,Default Letter Head,Uobičajeno Letter Head
DocType: Purchase Order,Get Items from Open Material Requests,Saznajte Predmeti od Open materijala Zahtjevi
DocType: Hotel Room Amenity,Billable,Naplativo
DocType: Lab Test Template,Standard Selling Rate,Standard prodajni kurs
DocType: Account,Rate at which this tax is applied,Stopa po kojoj je taj porez se primjenjuje
DocType: Cash Flow Mapper,Section Name,Naziv odeljka
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +85,Reorder Qty,Ponovno red Qty
apps/erpnext/erpnext/assets/doctype/asset/asset.py +283,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Redosled amortizacije {0}: Očekivana vrednost nakon korisnog veka mora biti veća ili jednaka {1}
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +55,Current Job Openings,Trenutni Otvori Posao
DocType: Company,Stock Adjustment Account,Stock Adjustment račun
apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Otpisati
DocType: Healthcare Service Unit,Allow Overlap,Dopusti preklapanje
DocType: Timesheet Detail,Operation ID,Operacija ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","ID korisnika sustava. Ako je postavljen, postat će zadani za sve HR oblike."
apps/erpnext/erpnext/assets/doctype/asset/asset.py +86,Enter depreciation details,Unesite podatke o amortizaciji
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: {1} Od
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py +31,Leave application {0} already exists against the student {1},Izlaz iz aplikacije {0} već postoji protiv učenika {1}
DocType: Task,depends_on,depends_on
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +78,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Očekuje se ažuriranje najnovije cene u svim materijalima. Može potrajati nekoliko minuta.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Ime novog računa. Napomena: Molimo vas da ne stvaraju račune za kupcima i dobavljačima
DocType: POS Profile,Display Items In Stock,Prikazivi proizvodi na raspolaganju
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Država mudar zadana adresa predlošci
DocType: Payment Order,Payment Order Reference,Referentni nalog za plaćanje
DocType: Water Analysis,Appearance,Izgled
DocType: HR Settings,Leave Status Notification Template,Ostavite šablon za statusno stanje
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +77,Avg. Buying Price List Rate,Avg. Kupovni cjenovnik
DocType: Sales Order Item,Supplier delivers to Customer,Dobavljač dostavlja kupaca
apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Informacije o članovima.
DocType: Identification Document Type,Identification Document Type,Identifikacioni tip dokumenta
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# obrazac / Stavka / {0}) je out of stock
apps/erpnext/erpnext/assets/doctype/asset/asset.js +87,Asset Maintenance,Održavanje imovine
,Sales Payment Summary,Sažetak prodaje plata
DocType: Restaurant,Restaurant,Restoran
DocType: Woocommerce Settings,API consumer key,API korisnički ključ
apps/erpnext/erpnext/accounts/party.py +353,Due / Reference Date cannot be after {0},Zbog / Reference Datum ne može biti nakon {0}
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Podataka uvoz i izvoz
DocType: Tax Withholding Category,Account Details,Detalji konta
DocType: Crop,Materials Required,Potrebni materijali
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,No studenti Found
DocType: Employee Tax Exemption Declaration,Monthly HRA Exemption,Mjesečna HRA izuzeća
DocType: Clinical Procedure,Medical Department,Medicinski odjel
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kriterijumi bodovanja rezultata ocenjivanja dobavljača
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Račun Datum knjiženja
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,prodati
DocType: Purchase Invoice,Rounded Total,Zaokruženi iznos
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +91,Slots for {0} are not added to the schedule,Slotovi za {0} se ne dodaju u raspored
DocType: Product Bundle,List items that form the package.,Popis stavki koje čine paket.
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +42,Not permitted. Please disable the Test Template,Nije dozvoljeno. Molim vas isključite Test Template
DocType: Delivery Note,Distance (in km),Udaljenost (u km)
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Postotak izdvajanja trebala bi biti jednaka 100 %
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +611,Please select Posting Date before selecting Party,Molimo odaberite Datum knjiženja prije izbora stranke
DocType: Program Enrollment,School House,School House
DocType: Serial No,Out of AMC,Od AMC
DocType: Opportunity,Opportunity Amount,Mogućnost Iznos
apps/erpnext/erpnext/assets/doctype/asset/asset.py +203,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Broj Amortizacija Booked ne može biti veća od Ukupan broj Amortizacija
DocType: Purchase Order,Order Confirmation Date,Datum potvrđivanja porudžbine
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Provjerite održavanja Posjetite
DocType: Employee Transfer,Employee Transfer Details,Detalji transfera zaposlenih
apps/erpnext/erpnext/selling/doctype/customer/customer.py +263,Please contact to the user who have Sales Master Manager {0} role,Molimo kontaktirajte za korisnike koji imaju Sales Manager Master {0} ulogu
DocType: Company,Default Cash Account,Zadani novčani račun
apps/erpnext/erpnext/config/accounts.py +79,Company (not Customer or Supplier) master.,Društvo ( ne kupaca i dobavljača ) majstor .
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,To se temelji na prisustvo ovog Student
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +179,No Students in,No Studenti u
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +180,Add more items or open full form,Dodaj više stavki ili otvoreni punu formu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Otpremnica {0} mora biti otkazana prije poništenja ove narudžbenice
apps/erpnext/erpnext/utilities/user_progress.py +259,Go to Users,Idite na Korisnike
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +113,Paid amount + Write Off Amount can not be greater than Grand Total,Uplaćeni iznos + otpis iznos ne može biti veći od SVEUKUPNO
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} nije ispravan broj serije za artikal {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +199,Note: There is not enough leave balance for Leave Type {0},Napomena : Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
apps/erpnext/erpnext/regional/india/utils.py +19,Invalid GSTIN or Enter NA for Unregistered,Nevažeći GSTIN ili Enter NA neregistriranim
DocType: Training Event,Seminar,seminar
DocType: Program Enrollment Fee,Program Enrollment Fee,Program Upis Naknada
DocType: Item,Supplier Items,Dobavljač Predmeti
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
DocType: Opportunity,Opportunity Type,Vrsta prilike
DocType: Asset Movement,To Employee,Za zaposlene
DocType: Employee Transfer,New Company,Nova firma
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +19,Transactions can only be deleted by the creator of the Company,Transakcije mogu se obrisati samo kreator Društva
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.,Neispravan broj glavnu knjigu unose naći. Možda ste odabrali krivi račun u transakciji.
DocType: Employee,Prefered Contact Email,Prefered Kontakt mail
DocType: Cheque Print Template,Cheque Width,Ček Širina
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Potvrditi prodajna cijena za artikl protiv kupovine objekta ili Vrednovanje Rate
DocType: Fee Schedule,Fee Schedule,naknada Raspored
DocType: Company,Create Chart Of Accounts Based On,Napravite Kontni plan na osnovu
apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Ne mogu ga pretvoriti u ne-grupu. Postoje zadaci za decu.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +122,Date of Birth cannot be greater than today.,Datum rođenja ne može biti veći nego što je danas.
,Stock Ageing,Kataloški Starenje
DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Delimično sponzorisani, zahtevaju delimično finansiranje"
apps/erpnext/erpnext/education/doctype/student/student.py +40,Student {0} exist against student applicant {1},Student {0} postoje protiv podnosioca prijave student {1}
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Prilagođavanje zaokruživanja (valuta kompanije)
apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,kontrolna kartica
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243,Batch: ,Serija:
DocType: Volunteer,Afternoon,Popodne
DocType: Loyalty Program,Loyalty Program Help,Pomoć programa za lojalnost
apps/erpnext/erpnext/controllers/accounts_controller.py +305,{0} '{1}' is disabled,{0} '{1}' je onemogućeno
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Postavi status Otvoreno
DocType: Cheque Print Template,Scanned Cheque,skeniranim Ček
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Pošaljite e-poštu automatski da Kontakti na podnošenje transakcija.
DocType: Timesheet,Total Billable Amount,Ukupno naplative iznos
DocType: Customer,Credit Limit and Payment Terms,Kreditni limit i uslovi plaćanja
DocType: Loyalty Program,Collection Rules,Pravila sakupljanja
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Stavka 3
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Unos naloga
DocType: Purchase Order,Customer Contact Email,Email kontakta kupca
DocType: Warranty Claim,Item and Warranty Details,Stavka i garancija Detalji
DocType: Chapter,Chapter Members,Članovi poglavlja
DocType: Sales Team,Contribution (%),Doprinos (%)
apps/erpnext/erpnext/controllers/accounts_controller.py +133,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Napomena : Stupanje Plaćanje neće biti izrađen od ' Gotovina ili bankovni račun ' nije naveden
apps/erpnext/erpnext/projects/doctype/project/project.py +79,Project {0} already exists,Projekat {0} već postoji
DocType: Clinical Procedure,Nursing User,Korisnik medicinske sestre
DocType: Employee Benefit Application,Payroll Period,Period plaćanja
DocType: Plant Analysis,Plant Analysis Criterias,Kriterijumi za analizu biljaka
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +239,Serial No {0} does not belong to Batch {1},Serijski broj {0} ne pripada Batch {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +220,Responsibilities,Odgovornosti
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Rok važnosti ove ponude je završen.
DocType: Expense Claim Account,Expense Claim Account,Rashodi Preuzmi računa
DocType: Account,Capital Work in Progress,Kapitalni rad je u toku
DocType: Accounts Settings,Allow Stale Exchange Rates,Dozvolite stare kurseve
DocType: Sales Person,Sales Person Name,Ime referenta prodaje
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Unesite atleast jedan račun u tablici
apps/erpnext/erpnext/utilities/user_progress.py +247,Add Users,Dodaj Korisnici
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py +74,No Lab Test created,Nije napravljen laboratorijski test
DocType: POS Item Group,Item Group,Grupa artikla
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +19,Student Group: ,Student Grupa:
DocType: Depreciation Schedule,Finance Book Id,Id Book of Finance
DocType: Item,Safety Stock,Sigurnost Stock
DocType: Healthcare Settings,Healthcare Settings,Postavke zdravstvene zaštite
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +8,Total Allocated Leaves,Ukupno izdvojene liste
apps/erpnext/erpnext/projects/doctype/task/task.py +54,Progress % for a task cannot be more than 100.,Napredak% za zadatak ne može biti više od 100.
DocType: Stock Reconciliation Item,Before reconciliation,Prije nego pomirenje
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Za {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Porezi i naknade uvrštenja (Društvo valuta)
apps/erpnext/erpnext/stock/doctype/item/item.py +493,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Stavka Porezna Row {0} mora imati račun tipa poreza ili prihoda i rashoda ili naplativ
DocType: Sales Order,Partly Billed,Djelomično Naplaćeno
apps/erpnext/erpnext/assets/doctype/asset/asset.py +54,Item {0} must be a Fixed Asset Item,Stavka {0} mora biti osnovna sredstva stavka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +286,HSN,HSN
apps/erpnext/erpnext/stock/doctype/item/item.js +421,Make Variants,Pravite varijante
DocType: Item,Default BOM,Zadani BOM
DocType: Project,Total Billed Amount (via Sales Invoices),Ukupan fakturisani iznos (preko faktura prodaje)
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +131,Debit Note Amount,Debitne Napomena Iznos
DocType: Project Update,Not Updated,Nije ažurirano
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +107,"There are inconsistencies between the rate, no of shares and the amount calculated","Postoje nedoslednosti između stope, bez dionica i iznosa obračunatog"
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +39,You are not present all day(s) between compensatory leave request days,Vi niste prisutni ceo dan između dana zahtjeva za kompenzacijski odmor
apps/erpnext/erpnext/setup/doctype/company/company.js +109,Please re-type company name to confirm,Molimo vas da ponovno tipa naziv firme za potvrdu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +234,Total Outstanding Amt,Ukupno Outstanding Amt
DocType: Journal Entry,Printing Settings,Printing Settings
DocType: Employee Advance,Advance Account,Advance Account
DocType: Job Offer,Job Offer Terms,Uslovi ponude posla
DocType: Sales Invoice,Include Payment (POS),Uključuju plaćanje (POS)
DocType: Shopify Settings,eg: frappe.myshopify.com,npr: frappe.myshopify.com
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +324,Total Debit must be equal to Total Credit. The difference is {0},Ukupno zaduženje mora biti jednak ukupnom kreditnom .
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Automobilska industrija
DocType: Vehicle,Insurance Company,Insurance Company
DocType: Asset Category Account,Fixed Asset Account,Osnovnih sredstava računa
DocType: Salary Structure Assignment,Variable,varijabla
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Od otpremnici
DocType: Chapter,Members,Članovi
DocType: Student,Student Email Address,Student-mail adresa
DocType: Item,Hub Warehouse,Hub skladište
DocType: Cashier Closing,From Time,S vremena
DocType: Hotel Settings,Hotel Settings,Hotel Settings
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Na raspolaganju:
DocType: Notification Control,Custom Message,Prilagođena poruka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investicijsko bankarstvo
DocType: Purchase Invoice,input,ulaz
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +107,Cash or Bank Account is mandatory for making payment entry,Novac ili bankovni račun je obvezna za izradu ulazak plaćanje
DocType: Loyalty Program,Multiple Tier Program,Multiple Tier Program
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,student adresa
DocType: Purchase Invoice,Price List Exchange Rate,Cjenik tečajna
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +116,All Supplier Groups,Sve grupe dobavljača
DocType: Employee Boarding Activity,Required for Employee Creation,Potrebno za stvaranje zaposlenih
apps/erpnext/erpnext/accounts/doctype/account/account.py +214,Account Number {0} already used in account {1},Broj računa {0} već se koristi na nalogu {1}
DocType: GoCardless Mandate,Mandate,Mandat
DocType: POS Profile,POS Profile Name,POS Profil Ime
DocType: Hotel Room Reservation,Booked,Rezervirano
DocType: Detected Disease,Tasks Created,Kreirani zadaci
DocType: Purchase Invoice Item,Rate,VPC
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +107,Intern,stažista
DocType: Delivery Stop,Address Name,Adresa ime
DocType: Stock Entry,From BOM,Iz BOM
DocType: Assessment Code,Assessment Code,procjena Kod
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +76,Basic,Osnovni
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Stock transakcije prije {0} se zamrznut
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',"Molimo kliknite na ""Generiraj raspored '"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +154,Reference No is mandatory if you entered Reference Date,Reference Ne obvezno ako ušao referentnog datuma
DocType: Bank Reconciliation Detail,Payment Document,plaćanje Document
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Greška u procjeni formula za kriterijume
apps/erpnext/erpnext/hr/doctype/employee/employee.py +125,Date of Joining must be greater than Date of Birth,Datum pristupa mora biti veći od datuma rođenja
DocType: Subscription,Plans,Planovi
DocType: Salary Slip,Salary Structure,Plaća Struktura
DocType: Account,Bank,Banka
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Aviokompanija
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +878,Issue Material,Tiketi - materijal
apps/erpnext/erpnext/config/integrations.py +32,Connect Shopify with ERPNext,Povežite Shopify sa ERPNext
DocType: Material Request Item,For Warehouse,Za galeriju
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +45,Delivery Notes {0} updated,Beleške o isporuci {0} ažurirane
DocType: Employee,Offer Date,ponuda Datum
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +35,Quotations,Citati
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Šifra proizvoda&gt; Grupa proizvoda&gt; Marka
apps/erpnext/erpnext/accounts/page/pos/pos.js +742,You are in offline mode. You will not be able to reload until you have network.,Vi ste u isključenom modu. Nećete biti u mogućnosti da ponovo sve dok imate mrežu.
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js +90,Grant,Grant
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,No studentskih grupa stvorio.
DocType: Purchase Invoice Item,Serial No,Serijski br
apps/erpnext/erpnext/hr/doctype/loan/loan.py +129,Monthly Repayment Amount cannot be greater than Loan Amount,Mjesečna otplate iznos ne može biti veći od iznos kredita
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Unesite prva Maintaince Detalji
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +59,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Red # {0}: Očekivani datum isporuke ne može biti pre datuma kupovine naloga
DocType: Purchase Invoice,Print Language,print Jezik
DocType: Salary Slip,Total Working Hours,Ukupno Radno vrijeme
DocType: Sales Invoice,Customer PO Details,Kupac PO Detalji
DocType: Stock Entry,Including items for sub assemblies,Uključujući i stavke za pod sklopova
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Privremeni račun za otvaranje
apps/erpnext/erpnext/accounts/page/pos/pos.js +1979,Enter value must be positive,Unesite vrijednost mora biti pozitivan
DocType: Asset,Finance Books,Finansijske knjige
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Kategorija izjave o izuzeću poreza na radnike
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +448,All Territories,Sve teritorije
apps/erpnext/erpnext/hr/utils.py +215,Please set leave policy for employee {0} in Employee / Grade record,Molimo navedite politiku odlaska za zaposlenog {0} u Zapisniku zaposlenih / razreda
apps/erpnext/erpnext/public/js/controllers/transaction.js +1405,Invalid Blanket Order for the selected Customer and Item,Neveljavna porudžbina za odabrani korisnik i stavku
apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49,Add Multiple Tasks,Dodajte više zadataka
DocType: Purchase Invoice,Items,Artikli
apps/erpnext/erpnext/crm/doctype/contract/contract.py +38,End Date cannot be before Start Date.,Krajnji datum ne može biti pre početka datuma.
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +33,Student is already enrolled.,Student je već upisana.
DocType: Fiscal Year,Year Name,Naziv godine
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +323,There are more holidays than working days this month.,Postoji više odmor nego radnih dana ovog mjeseca .
apps/erpnext/erpnext/controllers/buying_controller.py +760,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Sledeće stavke {0} nisu označene kao {1} stavka. Možete ih omogućiti kao {1} stavku iz glavnog poglavlja
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +101,PDC/LC Ref,PDC / LC Ref
DocType: Production Plan Item,Product Bundle Item,Proizvod Bundle Stavka
DocType: Sales Partner,Sales Partner Name,Prodaja Ime partnera
apps/erpnext/erpnext/hooks.py +141,Request for Quotations,Zahtjev za ponudu
DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimalni iznos fakture
DocType: Normal Test Items,Normal Test Items,Normalni testovi
DocType: Additional Salary,Overwrite Salary Structure Amount,Izmijeniti iznos plata
DocType: Student Language,Student Language,student Jezik
apps/erpnext/erpnext/config/selling.py +23,Customers,Kupci
DocType: Cash Flow Mapping,Is Working Capital,Je radni kapital
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Kako / Quot%
apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Snimite vitale pacijenta
DocType: Fee Schedule,Institution,institucija
DocType: Asset,Partially Depreciated,Djelomično oslabio
DocType: Issue,Opening Time,Radno vrijeme
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +97,From and To dates required,Od i Do datuma zahtijevanih
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Vrijednosni papiri i robne razmjene
apps/erpnext/erpnext/stock/doctype/item/item.py +740,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Uobičajeno mjerna jedinica za varijantu &#39;{0}&#39; mora biti isti kao u obrascu &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Izračun zasnovan na
DocType: Contract,Unfulfilled,Neispunjeno
DocType: Delivery Note Item,From Warehouse,Od Skladište
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +64,No employees for the mentioned criteria,Nema zaposlenih po navedenim kriterijumima
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1030,No Items with Bill of Materials to Manufacture,Nema artikala sa Bill materijala za proizvodnju
DocType: Shopify Settings,Default Customer,Podrazumevani korisnik
DocType: Sales Stage,Stage Name,Ime faze
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
DocType: Assessment Plan,Supervisor Name,Supervizor ime
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Ne potvrdite da li je zakazan termin za isti dan
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +267,Ship To State,Brod u državu
DocType: Program Enrollment Course,Program Enrollment Course,Program Upis predmeta
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py +59,User {0} is already assigned to Healthcare Practitioner {1},Korisnik {0} je već dodeljen Zdravstvenom lekaru {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +187,Make Sample Retention Stock Entry,Napravite uzorak zadržavanja uzorka uzorka
DocType: Purchase Taxes and Charges,Valuation and Total,Vrednovanje i Total
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +321,Negotiation/Review,Pregovaranje / pregled
DocType: Leave Encashment,Encashment Amount,Amount of Encashment
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Scorecards
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +159,Expired Batches,Istekao paketi
DocType: Employee,This will restrict user access to other employee records,Ovo će ograničiti pristup korisnika drugim zapisima zaposlenih
DocType: Tax Rule,Shipping City,Dostava City
DocType: Delivery Note,Ship,Brod
DocType: Staffing Plan Detail,Current Openings,Aktuelno otvaranje
DocType: Notification Control,Customize the Notification,Prilagodite Obavijest
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +78,Cash Flow from Operations,Novčani tok iz poslovanja
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +316,CGST Amount,CGST Iznos
DocType: Purchase Invoice,Shipping Rule,Pravilo transporta
DocType: Patient Relation,Spouse,Supružnik
DocType: Lab Test Groups,Add Test,Dodajte test
DocType: Manufacturer,Limited to 12 characters,Ograničena na 12 znakova
DocType: Journal Entry,Print Heading,Ispis Naslov
apps/erpnext/erpnext/config/stock.py +149,Delivery Trip service tours to customers.,Usluga pružanja usluga putovanja putnicima.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Ukupna ne može biti nula
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,' Dana od poslednje porudzbine ' mora biti veći ili jednak nuli
DocType: Plant Analysis Criteria,Maximum Permissible Value,Maksimalna dozvoljena vrijednost
DocType: Journal Entry Account,Employee Advance,Advance Employee
DocType: Payroll Entry,Payroll Frequency,Payroll Frequency
DocType: Lab Test Template,Sensitivity,Osjetljivost
apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py +132,Sync has been temporarily disabled because maximum retries have been exceeded,Sinhronizacija je privremeno onemogućena jer su prekoračeni maksimalni pokušaji
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1007,Raw Material,sirovine
DocType: Leave Application,Follow via Email,Slijedite putem e-maila
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +56,Plants and Machineries,Biljke i Machineries
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Iznos poreza Nakon iznosa popusta
DocType: Patient,Inpatient Status,Status bolesnika
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Svakodnevni rad Pregled Postavke
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1291,Selected Price List should have buying and selling fields checked.,Izabrana cenovna lista treba da ima provereno kupovinu i prodaju.
apps/erpnext/erpnext/controllers/buying_controller.py +681,Please enter Reqd by Date,Molimo unesite Reqd po datumu
DocType: Payment Entry,Internal Transfer,Interna Transfer
DocType: Asset Maintenance,Maintenance Tasks,Zadaci održavanja
apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Ili meta Količina ili ciljani iznos je obvezna
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +627,Please select Posting Date first,Molimo najprije odaberite Datum knjiženja
apps/erpnext/erpnext/public/js/account_tree_grid.js +209,Opening Date should be before Closing Date,Otvaranje Datum bi trebao biti prije zatvaranja datum
DocType: Travel Itinerary,Flight,Let
DocType: Leave Control Panel,Carry Forward,Prenijeti
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +32,Cost Center with existing transactions can not be converted to ledger,Troška s postojećim transakcija ne može pretvoriti u knjizi
DocType: Budget,Applicable on booking actual expenses,Primenjuje se prilikom rezervisanja stvarnih troškova
DocType: Department,Days for which Holidays are blocked for this department.,Dani za koje su praznici blokirani za ovaj odjel.
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNext Integrations
DocType: Crop Cycle,Detected Disease,Detektovana bolest
,Produced,Proizvedeno
apps/erpnext/erpnext/hr/doctype/loan/loan.py +26,Repayment Start Date cannot be before Disbursement Date.,Datum početka otplate ne može biti prije datuma isplate.
DocType: Item,Item Code for Suppliers,Šifra za dobavljače
DocType: Issue,Raised By (Email),Pokrenuo (E-mail)
DocType: Training Event,Trainer Name,trener ime
DocType: Mode of Payment,General,Opšti
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Zadnje Komunikacija
,TDS Payable Monthly,TDS se plaća mesečno
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +73,Queued for replacing the BOM. It may take a few minutes.,Očekuje se zamena BOM-a. Može potrajati nekoliko minuta.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +385,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Ne mogu odbiti kada kategorija je "" vrednovanje "" ili "" Vrednovanje i Total '"
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +286,Serial Nos Required for Serialized Item {0},Serijski Nos potrebna za serijaliziranom točke {0}
apps/erpnext/erpnext/config/accounts.py +167,Match Payments with Invoices,Meč plaćanja fakture
DocType: Journal Entry,Bank Entry,Bank Entry
DocType: Authorization Rule,Applicable To (Designation),Odnosi se na (Oznaka)
,Profitability Analysis,Analiza profitabilnosti
DocType: Fees,Student Email,Student Email
DocType: Supplier,Prevent POs,Sprečite PO
DocType: Patient,"Allergies, Medical and Surgical History","Alergije, medicinska i hirurška istorija"
apps/erpnext/erpnext/templates/generators/item.html +96,Add to Cart,Dodaj u košaricu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +197,Group By,Group By
DocType: Guardian,Interests,Interesi
apps/erpnext/erpnext/config/accounts.py +336,Enable / disable currencies.,Omogućiti / onemogućiti valute .
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +549,Could not submit some Salary Slips,Ne mogu da podnesem neke plate
DocType: Exchange Rate Revaluation,Get Entries,Get Entries
DocType: Production Plan,Get Material Request,Get materijala Upit
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Postal Expenses,Poštanski troškovi
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html +8,Sales Summary,Sažetak prodaje
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Ukupno (Amt)
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Zabava i slobodno vrijeme
,Item Variant Details,Detalji varijante proizvoda
DocType: Quality Inspection,Item Serial No,Serijski broj artikla
DocType: Payment Request,Is a Subscription,Je Pretplata
apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Kreiranje zaposlenih Records
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Present,Ukupno Present
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
apps/erpnext/erpnext/config/accounts.py +122,Accounting Statements,knjigovodstvene isprave
DocType: Drug Prescription,Hour,Sat
DocType: Restaurant Order Entry,Last Sales Invoice,Poslednja prodaja faktura
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +867,Please select Qty against item {0},Molimo izaberite Qty protiv stavke {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +33,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Novi serijski broj ne može imati skladište. Skladište mora biti postavljen od strane burze upisu ili kupiti primitka
DocType: Lead,Lead Type,Tip potencijalnog kupca
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +183,You are not authorized to approve leaves on Block Dates,Niste ovlašteni za odobravanje lišće na bloku Termini
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +405,All these items have already been invoiced,Svi ovi artikli su već fakturisani
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +1017,Set New Release Date,Podesite novi datum izdanja
DocType: Company,Monthly Sales Target,Mesečni cilj prodaje
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Može biti odobren od strane {0}
DocType: Hotel Room,Hotel Room Type,Tip sobe hotela
DocType: Leave Allocation,Leave Period,Ostavite Period
DocType: Item,Default Material Request Type,Uobičajeno materijala Upit Tip
DocType: Supplier Scorecard,Evaluation Period,Period evaluacije
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,nepoznat
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1029,Work Order not created,Radni nalog nije kreiran
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +36,"An amount of {0} already claimed for the component {1},\
						 set the amount equal or greater than {2}","Količina {0} koja je već zahtevana za komponentu {1}, \ postavite količinu jednaka ili veća od {2}"
DocType: Shipping Rule,Shipping Rule Conditions,Uslovi pravila transporta
DocType: Purchase Invoice,Export Type,Tip izvoza
DocType: Salary Slip Loan,Salary Slip Loan,Loan Slip Loan
DocType: BOM Update Tool,The new BOM after replacement,Novi BOM nakon zamjene
,Point of Sale,Point of Sale
DocType: Payment Entry,Received Amount,Primljeni Iznos
DocType: Patient,Widow,Udovica
DocType: GST Settings,GSTIN Email Sent On,GSTIN mail poslan
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop Guardian
DocType: Bank Account,SWIFT number,SWIFT broj
DocType: Payment Entry,Party Name,Party ime
DocType: Employee Benefit Application,Benefits Applied,Prednosti koje se primjenjuju
DocType: Crop,Planting UOM,Sadnja UOM
DocType: Account,Tax,Porez
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,neobilježen
DocType: Contract,Signed,Potpisano
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Otvaranje rezimea faktura
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
DocType: Education Settings,Education Manager,Menadžer obrazovanja
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimalna dužina između svake biljke u polju za optimalan rast
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +153,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Dozirano Stavka {0} ne može se ažurirati pomoću Stock pomirenje, umjesto da koriste Stock Entry"
DocType: Quality Inspection,Report Date,Prijavi Datum
DocType: Student,Middle Name,Srednje ime
DocType: BOM,Routing,Routing
DocType: Serial No,Asset Details,Detalji o aktivi
DocType: Bank Statement Transaction Payment Item,Invoices,Fakture
DocType: Water Analysis,Type of Sample,Tip uzorka
DocType: Batch,Source Document Name,Izvor Document Name
DocType: Production Plan,Get Raw Materials For Production,Uzmite sirovine za proizvodnju
DocType: Job Opening,Job Title,Titula
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +89,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} označava da {1} neće dati citat, ali su svi stavci \ citirani. Ažuriranje statusa RFQ citata."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1290,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maksimalni uzorci - {0} su već zadržani za Batch {1} i Item {2} u Batch {3}.
DocType: Manufacturing Settings,Update BOM Cost Automatically,Ažurirajte BOM trošak automatski
DocType: Lab Test,Test Name,Ime testa
DocType: Healthcare Settings,Clinical Procedure Consumable Item,Klinička procedura Potrošna stavka
apps/erpnext/erpnext/utilities/activation.py +99,Create Users,kreiranje korisnika
apps/erpnext/erpnext/utilities/user_progress.py +147,Gram,gram
apps/erpnext/erpnext/accounts/doctype/subscriber/subscriber_dashboard.py +10,Subscriptions,Pretplate
DocType: Supplier Scorecard,Per Month,Mjesečno
DocType: Education Settings,Make Academic Term Mandatory,Obavezni akademski termin
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,Količina za proizvodnju mora biti veći od 0.
DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Izračunajte proporcionalnu amortizaciju na osnovu fiskalne godine
apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Posjetite izvješće za održavanje razgovora.
DocType: Stock Entry,Update Rate and Availability,Ažuriranje Rate i raspoloživost
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.,Postotak koju smiju primiti ili isporučiti više od naručene količine. Na primjer: Ako ste naručili 100 jedinica. i tvoj ispravak je 10% onda se smiju primati 110 jedinica.
DocType: Loyalty Program,Customer Group,Vrsta djelatnosti Kupaca
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +296,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs,Red # {0}: Operacija {1} nije završena za {2} količina gotove robe u Work Order # {3}. Molimo ažurirajte status operacije preko Time Logs-a
apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),New Batch ID (opcionalno)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +229,Expense account is mandatory for item {0},Rashodi račun je obvezna za predmet {0}
DocType: BOM,Website Description,Web stranica Opis
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +101,Net Change in Equity,Neto promjena u kapitalu
apps/erpnext/erpnext/assets/doctype/asset/asset.py +291,Please cancel Purchase Invoice {0} first,Molimo vas da otkaže fakturi {0} prvi
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py +25,Not permitted. Please disable the Service Unit Type,Nije dozvoljeno. Molim vas isključite Type Service Service Unit
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-mail adresa mora biti jedinstvena, već postoji za {0}"
DocType: Serial No,AMC Expiry Date,AMC Datum isteka
DocType: Asset,Receipt,priznanica
,Sales Register,Prodaja Registracija
DocType: Daily Work Summary Group,Send Emails At,Pošalji e-mailova
DocType: Quotation,Quotation Lost Reason,Razlog nerealizirane ponude
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +383,Transaction reference no {0} dated {1},Transakcija Ref {0} od {1}
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js +5,There is nothing to edit.,Ne postoji ništa za uređivanje .
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +542,Form View,Form View
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Troškovi odobrenja obavezni u potraživanju troškova
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +124,Summary for this month and pending activities,Sažetak za ovaj mjesec i aktivnostima na čekanju
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py +91,Please set Unrealized Exchange Gain/Loss Account in Company {0},Molimo da unesete Nerealizovani Exchange Gain / Loss Account u kompaniji {0}
apps/erpnext/erpnext/utilities/user_progress.py +248,"Add users to your organization, other than yourself.","Dodajte korisnike u svoju organizaciju, osim sebe."
DocType: Customer Group,Customer Group Name,Naziv vrste djelatnosti Kupca
apps/erpnext/erpnext/public/js/pos/pos.html +109,No Customers yet!,Ne Kupci još!
DocType: Healthcare Service Unit,Healthcare Service Unit,Jedinica za zdravstvenu zaštitu
apps/erpnext/erpnext/public/js/financial_statements.js +58,Cash Flow Statement,Izvještaj o novčanim tokovima
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +467,No material request created,Nije napravljen materijalni zahtev
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Iznos kredita ne može biti veći od Maksimalni iznos kredita od {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Licenca
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +562,Please remove this Invoice {0} from C-Form {1},Molimo vas da uklonite ovu fakture {0} iz 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,Molimo odaberite prenositi ako želite uključiti prethodnoj fiskalnoj godini je ravnoteža ostavlja na ovoj fiskalnoj godini
DocType: GL Entry,Against Voucher Type,Protiv voucher vrsti
DocType: Healthcare Practitioner,Phone (R),Telefon (R)
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +104,Time slots added,Dodato je vremenska utrka
DocType: Item,Attributes,Atributi
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +36,Enable Template,Omogući šablon
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +254,Please enter Write Off Account,Unesite otpis račun
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Last Order Datum
DocType: Salary Component,Is Payable,Da li se plaća
DocType: Inpatient Record,B Negative,B Negativno
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Status održavanja mora biti poništen ili završen za slanje
DocType: Amazon MWS Settings,US,SAD
DocType: Holiday List,Add Weekly Holidays,Dodajte Weekly Holidays
DocType: Staffing Plan Detail,Vacancies,Slobodna radna mesta
DocType: Hotel Room,Hotel Room,Hotelska soba
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +57,Account {0} does not belongs to company {1},Računa {0} ne pripada kompaniji {1}
DocType: Leave Type,Rounding,Zaokruživanje
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +987,Serial Numbers in row {0} does not match with Delivery Note,Serijski brojevi u nizu {0} ne odgovara otpremnica
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),Dispensed Amount (Pro-rated)
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 Group, Campaign, Sales Partner etc.","Tada Pravila cene se filtriraju na osnovu klijenta, grupe potrošača, teritorije, dobavljača, grupe dobavljača, kampanje, prodajnog partnera itd."
DocType: Student,Guardian Details,Guardian Detalji
DocType: C-Form,C-Form,C-Form
DocType: Agriculture Task,Start Day,Početak dana
DocType: Vehicle,Chassis No,šasija Ne
DocType: Payment Request,Initiated,Inicirao
DocType: Production Plan Item,Planned Start Date,Planirani Ozljede Datum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +643,Please select a BOM,Izaberite BOM
DocType: Purchase Invoice,Availed ITC Integrated Tax,Korišćen ITC integrisani porez
DocType: Purchase Order Item,Blanket Order Rate,Stopa porudžbine odeće
apps/erpnext/erpnext/hooks.py +157,Certification,Certifikat
DocType: Bank Guarantee,Clauses and Conditions,Klauzule i uslovi
DocType: Serial No,Creation Document Type,Tip stvaranje dokumenata
DocType: Project Task,View Timesheet,View Timesheet
DocType: Amazon MWS Settings,ES,ES
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js +24,Make Journal Entry,Make Journal Entry
DocType: Leave Allocation,New Leaves Allocated,Novi Leaves Dodijeljeni
apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Projekat - mudar podaci nisu dostupni za ponudu
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Završi
DocType: Project,Expected End Date,Očekivani Datum završetka
DocType: Budget Account,Budget Amount,budžet Iznos
DocType: Donor,Donor Name,Ime donatora
DocType: Journal Entry,Inter Company Journal Entry Reference,Referenca za unos dnevnika Inter Company
DocType: Appraisal Template,Appraisal Template Title,Procjena Predložak Naslov
apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,trgovački
DocType: Patient,Alcohol Current Use,Upotreba alkohola
DocType: Employee Tax Exemption Proof Submission,House Rent Payment Amount,Iznajmljivanje kuće
DocType: Student Admission Program,Student Admission Program,Studentski program za prijem studenata
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,Kategorija oporezivanja
DocType: Payment Entry,Account Paid To,Račun Paid To
DocType: Subscription Settings,Grace Period,Grace Period
DocType: Item Alternative,Alternative Item Name,Alternativni naziv predmeta
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Roditelj Stavka {0} ne smije biti Stock Item
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +187,Website Listing,Listing na sajtu
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Svi proizvodi i usluge.
DocType: Email Digest,Open Quotations,Open Quotations
DocType: Expense Claim,More Details,Više informacija
DocType: Supplier Quotation,Supplier Address,Dobavljač Adresa
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +168,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} budžeta za računa {1} protiv {2} {3} je {4}. To će premašiti po {5}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Od kol
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +49,Series is mandatory,Serija je obvezno
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,financijske usluge
DocType: Student Sibling,Student ID,student ID
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +214,For Quantity must be greater than zero,Za količinu mora biti veća od nule
apps/erpnext/erpnext/config/projects.py +51,Types of activities for Time Logs,Vrste aktivnosti za vrijeme Trupci
DocType: Opening Invoice Creation Tool,Sales,Prodaja
DocType: Stock Entry Detail,Basic Amount,Osnovni iznos
DocType: Training Event,Exam,ispit
apps/erpnext/erpnext/public/js/hub/hub_call.js +46,Marketplace Error,Greška na tržištu
DocType: Complaint,Complaint,Žalba
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +533,Warehouse required for stock Item {0},Skladište je potrebno za skladišne proizvode {0}
DocType: Leave Allocation,Unused leaves,Neiskorišteni lišće
apps/erpnext/erpnext/hr/doctype/loan/loan.js +83,Make Repayment Entry,Unošenje otplate
apps/erpnext/erpnext/patches/v11_0/update_department_lft_rgt.py +8,All Departments,Svi odjeli
DocType: Healthcare Service Unit,Vacant,Slobodno
DocType: Patient,Alcohol Past Use,Upotreba alkohola u prošlosti
DocType: Fertilizer Content,Fertilizer Content,Sadržaj đubriva
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +248,Cr,Cr
DocType: Project Update,Problematic/Stuck,Problematic / Stuck
DocType: Tax Rule,Billing State,State billing
DocType: Share Transfer,Transfer,Prijenos
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +262,Work Order {0} must be cancelled before cancelling this Sales Order,Radni nalog {0} mora biti otkazan prije otkazivanja ovog prodajnog naloga
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +995,Fetch exploded BOM (including sub-assemblies),Fetch eksplodirala BOM (uključujući i podsklopova )
DocType: Authorization Rule,Applicable To (Employee),Odnosi se na (Radnik)
apps/erpnext/erpnext/controllers/accounts_controller.py +170,Due Date is mandatory,Due Date je obavezno
apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Prirast za Atributi {0} ne može biti 0
DocType: Employee Benefit Claim,Benefit Type and Amount,Tip i iznos povlastice
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Sobe rezervirane
apps/erpnext/erpnext/crm/doctype/lead/lead.py +57,Ends On date cannot be before Next Contact Date.,Završava na datum ne može biti pre Sledećeg datuma kontakta.
DocType: Journal Entry,Pay To / Recd From,Platiti Da / RecD Od
DocType: Naming Series,Setup Series,Postavljanje Serija
DocType: Payment Reconciliation,To Invoice Date,Da biste Datum računa
DocType: Bank Account,Contact HTML,Kontakt HTML
DocType: Support Settings,Support Portal,Portal za podršku
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Kotizacija ne može biti nula
DocType: Disease,Treatment Period,Period lečenja
DocType: Travel Itinerary,Travel Itinerary,Putni put
apps/erpnext/erpnext/education/api.py +336,Result already Submitted,Rezultat već podnet
apps/erpnext/erpnext/controllers/buying_controller.py +197,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervisano skladište je obavezno za stavku {0} u isporučenim sirovinama
,Inactive Customers,neaktivnih kupaca
DocType: Student Admission Program,Maximum Age,Maksimalno doba
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,Molim vas sačekajte 3 dana pre ponovnog podnošenja podsetnika.
DocType: Landed Cost Voucher,Purchase Receipts,Kupovina Primici
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Kako se primjenjuje pravilo cijena?
DocType: Stock Entry,Delivery Note No,Otpremnica br
DocType: Cheque Print Template,Message to show,Poruke za prikaz
apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Maloprodaja
DocType: Student Attendance,Absent,Odsutan
DocType: Staffing Plan,Staffing Plan Detail,Detaljno planiranje osoblja
DocType: Employee Promotion,Promotion Date,Datum promocije
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +615,Product Bundle,Bundle proizvoda
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,Nije moguće pronaći rezultat od {0}. Morate imati stojeće rezultate koji pokrivaju 0 do 100
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,Row {0}: Invalid reference {1},Red {0}: Invalid referentni {1}
apps/erpnext/erpnext/assets/doctype/location/location_tree.js +23,New Location,Nova lokacija
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kupiti poreza i naknada Template
DocType: Subscription,Current Invoice Start Date,Trenutni datum početka fakture
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}: Ili debitne ili kreditne iznos je potreban za {2}
DocType: GL Entry,Remarks,Primjedbe
DocType: Hotel Room Amenity,Hotel Room Amenity,Hotelska soba Amenity
DocType: Budget,Action if Annual Budget Exceeded on MR,Akcija ako je godišnji budžet prešao na MR
DocType: Payment Entry,Account Paid From,Računa isplaćuju iz
DocType: Purchase Order Item Supplied,Raw Material Item Code,Sirovine Stavka Šifra
DocType: Task,Parent Task,Zadatak roditelja
DocType: Journal Entry,Write Off Based On,Otpis na temelju
apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Make Olovo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Print and Stationery,Print i pribora
DocType: Stock Settings,Show Barcode Field,Pokaži Barcode Field
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +859,Send Supplier Emails,Pošalji dobavljač Email
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +165,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plaća je već pripremljena za period od {0} i {1}, Ostavi period aplikacija ne može da bude između tog datuma opseg."
DocType: Fiscal Year,Auto Created,Automatski kreiran
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +19,Submit this to create the Employee record,Pošaljite ovo da biste napravili zapis Zaposlenog
DocType: Item Default,Item Default,Stavka Default
DocType: Chapter Member,Leave Reason,Ostavite razlog
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +197,Invoice {0} no longer exists,Račun {0} više ne postoji
DocType: Guardian Interest,Guardian Interest,Guardian interesa
DocType: Volunteer,Availability,Dostupnost
apps/erpnext/erpnext/config/accounts.py +357,Setup default values for POS Invoices,Podesi podrazumevane vrednosti za POS Račune
apps/erpnext/erpnext/config/hr.py +248,Training,trening
DocType: Project,Time to send,Vreme za slanje
DocType: Timesheet,Employee Detail,Detalji o radniku
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py +19,Set warehouse for Procedure {0} ,Postavite skladište za proceduru {0}
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
DocType: Lab Prescription,Test Code,Test Code
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Postavke za web stranice homepage
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +895,{0} is on hold till {1},{0} je na čekanju do {1}
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ-ovi nisu dozvoljeni za {0} zbog stanja karte za rezultat {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +9,Used Leaves,Korišćeni listovi
DocType: Job Offer,Awaiting Response,Čeka se odgovor
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-YYYY.-
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +83,Above,Iznad
DocType: Support Search Source,Link Options,Link Options
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1557,Total Amount {0},Ukupni iznos {0}
apps/erpnext/erpnext/controllers/item_variant.py +323,Invalid attribute {0} {1},Nevažeći atributa {0} {1}
DocType: Supplier,Mention if non-standard payable account,Navesti ukoliko nestandardnog plaća račun
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25,Please select the assessment group other than 'All Assessment Groups',"Molimo odaberite grupu procjene, osim &#39;Svi Procjena grupe&#39;"
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Red {0}: Troškovni centar je potreban za stavku {1}
DocType: Training Event Employee,Optional,Neobavezno
DocType: Salary Slip,Earning & Deduction,Zarada &amp; Odbitak
DocType: Agriculture Analysis Criteria,Water Analysis,Analiza vode
apps/erpnext/erpnext/stock/doctype/item/item.js +470,{0} variants created.,{0} kreirane varijante.
DocType: Amazon MWS Settings,Region,Regija
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,Izborni . Ova postavka će se koristiti za filtriranje u raznim transakcijama .
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +111,Negative Valuation Rate is not allowed,Negativna stopa vrijednovanja nije dopuštena
DocType: Holiday List,Weekly Off,Tjedni Off
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Ponovo učitaj analizu
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Za npr. 2012, 2012-13"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +99,Provisional Profit / Loss (Credit),Privremeni dobit / gubitak (Credit)
DocType: Sales Invoice,Return Against Sales Invoice,Vratiti Protiv Sales fakture
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Stavka 5
DocType: Serial No,Creation Time,vrijeme kreiranja
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Ukupan prihod
DocType: Patient,Other Risk Factors,Ostali faktori rizika
DocType: Sales Invoice,Product Bundle Help,Proizvod Bundle Pomoć
,Monthly Attendance Sheet,Mjesečna posjećenost list
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15,No record found,Ne rekord naći
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Cost of Scrapped Asset,Troškovi Rashodovan imovine
apps/erpnext/erpnext/controllers/stock_controller.py +240,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: trošak je obvezan za artikal {2}
DocType: Vehicle,Policy No,Politika Nema
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +736,Get Items from Product Bundle,Saznajte Predmeti od Bundle proizvoda
DocType: Asset,Straight Line,Duž
DocType: Project User,Project User,Korisnik projekta
apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,Split,Podijeliti
DocType: Employee Transfer,Re-allocate Leaves,Ponovo dodelite listove
DocType: GL Entry,Is Advance,Je avans
apps/erpnext/erpnext/config/hr.py +202,Employee Lifecycle,Životni vek zaposlenih
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Gledatelja Od datuma i posjećenost do sada je obvezno
apps/erpnext/erpnext/controllers/buying_controller.py +184,Please enter 'Is Subcontracted' as Yes or No,Unesite ' Je podugovoren ' kao da ili ne
DocType: Item,Default Purchase Unit of Measure,Podrazumevana jedinica kupovine mjere
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Zadnje Komunikacija Datum
DocType: Clinical Procedure Item,Clinical Procedure Item,Klinička procedura
DocType: Sales Team,Contact No.,Kontakt broj
DocType: Bank Reconciliation,Payment Entries,plaćanje unosi
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py +33,Access token or Shopify URL missing,Nije dostupan token ili Shopify URL
DocType: Location,Latitude,Latitude
DocType: Work Order,Scrap Warehouse,Scrap Skladište
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +191,"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}","Skladište je potrebno na redosledu {0}, molimo postavite podrazumevano skladište za predmet {1} za kompaniju {2}"
DocType: Work Order,Check if material transfer entry is not required,Provjerite da li se ne traži upis prenosa materijala
DocType: Program Enrollment Tool,Get Students From,Get Studenti iz
apps/erpnext/erpnext/config/learn.py +263,Publish Items on Website,Objavite Artikli na sajtu
apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Grupa svojim učenicima u serijama
DocType: Authorization Rule,Authorization Rule,Autorizacija Pravilo
DocType: POS Profile,Offline POS Section,Offline POS odjeljak
DocType: Sales Invoice,Terms and Conditions Details,Uvjeti Detalji
apps/erpnext/erpnext/templates/generators/item.html +118,Specifications,tehnički podaci
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Prodaja poreza i naknada Template
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +70,Total (Credit),Ukupno (kredit)
DocType: Repayment Schedule,Payment Date,Datum plaćanja
apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,New Batch Količina
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Odjeća i modni dodaci
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.,Nije moguće riješiti funkciju ponderisane ocjene. Proverite da li je formula validna.
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +186,Purchase Order Items not received on time,Stavke porudžbine nisu blagovremeno dobijene
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Broj Order
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / baner koji će se prikazivati na vrhu liste proizvoda.
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Odredite uvjete za izračunavanje iznosa shipping
DocType: Program Enrollment,Institute's Bus,Institutski autobus
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Uloga Dozvoljena Set Frozen Accounts & Frozen Edit unosi
DocType: Supplier Scorecard Scoring Variable,Path,Put
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cannot convert Cost Center to ledger as it has child nodes,"Ne može se pretvoriti troška za knjigu , kao da ima djece čvorova"
DocType: Production Plan,Total Planned Qty,Ukupna planirana količina
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +76,Opening Value,otvaranje vrijednost
DocType: Salary Component,Formula,formula
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
DocType: Lab Test Template,Lab Test Template,Lab test šablon
apps/erpnext/erpnext/setup/doctype/company/company.py +196,Sales Account,Račun prodaje
DocType: Purchase Invoice Item,Total Weight,Ukupna tezina
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +101,Commission on Sales,Komisija za prodaju
DocType: Job Offer Term,Value / Description,Vrijednost / Opis
apps/erpnext/erpnext/controllers/accounts_controller.py +690,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} ne može se podnijeti, to je već {2}"
DocType: Tax Rule,Billing Country,Billing Country
DocType: Purchase Order Item,Expected Delivery Date,Očekivani rok isporuke
DocType: Restaurant Order Entry,Restaurant Order Entry,Restoran za unos naloga
apps/erpnext/erpnext/accounts/general_ledger.py +134,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debitne i kreditne nije jednaka za {0} {1} #. Razlika je u tome {2}.
DocType: Clinical Procedure Item,Invoice Separately as Consumables,Faktura posebno kao Potrošni materijal
DocType: Budget,Control Action,Kontrolna akcija
DocType: Asset Maintenance Task,Assign To Name,Dodeli ime
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +105,Entertainment Expenses,Zabava Troškovi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98,Make Material Request,Make Materijal Upit
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Otvorena Stavka {0}
DocType: Asset Finance Book,Written Down Value,Pisanje vrednosti
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodaja Račun {0} mora biti otkazana prije poništenja ovu prodajnog naloga
DocType: Clinical Procedure,Age,Starost
DocType: Sales Invoice Timesheet,Billing Amount,Billing Iznos
DocType: Cash Flow Mapping,Select Maximum Of 1,Izaberite maksimum od 1
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Navedena je pogrešna količina za proizvod {0}. Količina treba biti veći od 0.
DocType: Company,Default Employee Advance Account,Uobičajeni uposni račun zaposlenog
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1181,Search Item (Ctrl + i),Pretraga stavke (Ctrl + i)
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.py +171,Account with existing transaction can not be deleted,Konto sa postojećim transakcijama se ne može izbrisati
DocType: Vehicle,Last Carbon Check,Zadnji Carbon Check
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Legal Expenses,Pravni troškovi
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +147,Please select quantity on row ,Molimo odaberite Količina na red
apps/erpnext/erpnext/config/accounts.py +315,Make Opening Sales and Purchase Invoices,Otvorite račune za prodaju i kupovinu
DocType: Purchase Invoice,Posting Time,Objavljivanje Vrijeme
DocType: Timesheet,% Amount Billed,% Naplaćenog iznosa
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +125,Telephone Expenses,Telefonski troškovi
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.,Označite ovo ako želite prisiliti korisniku odabir seriju prije spremanja. Tu će biti zadana ako to provjerili.
apps/erpnext/erpnext/stock/get_item_details.py +150,No Item with Serial No {0},No Stavka s rednim brojem {0}
DocType: Email Digest,Open Notifications,Otvorena obavjestenja
DocType: Payment Entry,Difference Amount (Company Currency),Razlika Iznos (Company Valuta)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +83,Direct Expenses,Direktni troškovi
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,New Customer prihoda
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Travel Expenses,putni troškovi
DocType: Maintenance Visit,Breakdown,Slom
DocType: Travel Itinerary,Vegetarian,Vegetarijanac
DocType: Patient Encounter,Encounter Date,Datum susreta
apps/erpnext/erpnext/controllers/accounts_controller.py +891,Account: {0} with currency: {1} can not be selected,Račun: {0} s valutnom: {1} se ne mogu odabrati
DocType: Bank Statement Transaction Settings Item,Bank Data,Podaci banke
DocType: Purchase Receipt Item,Sample Quantity,Količina uzorka
DocType: Bank Guarantee,Name of Beneficiary,Ime korisnika
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Automatsko ažuriranje troškova BOM-a putem Planera, na osnovu najnovije procene stope / cenovnika / poslednje stope sirovina."
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
DocType: Bank Reconciliation Detail,Cheque Date,Datum čeka
apps/erpnext/erpnext/accounts/doctype/account/account.py +57,Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Nadređeni konto {1} ne pripada preduzeću: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +126,Successfully deleted all transactions related to this company!,Uspješno obrisane sve transakcije koje se odnose na ove kompanije!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +39,As on Date,Kao i na datum
DocType: Additional Salary,HR,HR
DocType: Program Enrollment,Enrollment Date,upis Datum
DocType: Healthcare Settings,Out Patient SMS Alerts,Out Patient SMS upozorenja
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Probation,Probni rad
DocType: Program Enrollment Tool,New Academic Year,Nova akademska godina
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +866,Return / Credit Note,Povratak / Credit Note
DocType: Stock Settings,Auto insert Price List rate if missing,Auto umetak Cjenik stopa ako nedostaje
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +130,Total Paid Amount,Ukupno uplaćeni iznos
DocType: GST Settings,B2C Limit,B2C Limit
DocType: Job Card,Transferred Qty,prebačen Kol
apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigacija
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +164,Planning,planiranje
DocType: Contract,Signee,Signee
DocType: Share Balance,Issued,Izdao
DocType: Loan,Repayment Start Date,Datum početka otplate
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,student aktivnost
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Dobavljač Id
DocType: Payment Request,Payment Gateway Details,Payment Gateway Detalji
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +285,Quantity should be greater than 0,Količina bi trebao biti veći od 0
DocType: Journal Entry,Cash Entry,Cash Entry
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Dijete čvorovi se mogu kreirati samo pod &#39;Grupa&#39; tipa čvorova
DocType: Attendance Request,Half Day Date,Pola dana datum
DocType: Academic Year,Academic Year Name,Akademska godina Ime
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1175,{0} not allowed to transact with {1}. Please change the Company.,{0} nije dozvoljeno da radi sa {1}. Zamijenite Kompaniju.
DocType: Sales Partner,Contact Desc,Kontakt ukratko
DocType: Email Digest,Send regular summary reports via Email.,Pošalji redovne zbirne izvještaje putem e-maila.
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +288,Please set default account in Expense Claim Type {0},Molimo podesite zadani račun u Rashodi Preuzmi Tip {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +11,Available Leaves,Raspoložive liste
DocType: Assessment Result,Student Name,ime studenta
DocType: Hub Tracked Item,Item Manager,Stavka Manager
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Payroll Payable,Payroll plaćaju
DocType: Plant Analysis,Collection Datetime,Kolekcija Datetime
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Work Order,Total Operating Cost,Ukupni trošak
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +172,Note: Item {0} entered multiple times,Napomena : Stavka {0} upisan je više puta
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Svi kontakti.
DocType: Accounting Period,Closed Documents,Zatvoreni dokumenti
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,Upravljanje imenovanjima Faktura podnosi i otkazati automatski za susret pacijenta
DocType: Patient Appointment,Referring Practitioner,Poznavanje lekara
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Skraćeni naziv preduzeća
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py +51,User {0} does not exist,Korisnik {0} ne postoji
DocType: Payment Term,Day(s) after invoice date,Dan (a) nakon datuma fakture
apps/erpnext/erpnext/setup/doctype/company/company.js +34,Date of Commencement should be greater than Date of Incorporation,Datum početka trebalo bi da bude veći od Datum osnivanja
DocType: Contract,Signed On,Signed On
DocType: Bank Account,Party Type,Party Tip
DocType: Payment Schedule,Payment Schedule,Raspored plaćanja
DocType: Item Attribute Value,Abbreviation,Skraćenica
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +220,Payment Entry already exists,Plaćanje Entry već postoji
DocType: Subscription,Trial Period End Date,Datum završetka probnog perioda
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Ne authroized od {0} prelazi granice
DocType: Serial No,Asset Status,Status imovine
DocType: Delivery Note,Over Dimensional Cargo (ODC),Over Dimensional Cargo (ODC)
DocType: Restaurant Order Entry,Restaurant Table,Restoran Stol
DocType: Hotel Room,Hotel Manager,Menadžer hotela
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +64,Set Tax Rule for shopping cart,Set poreza Pravilo za košarica
DocType: Purchase Invoice,Taxes and Charges Added,Porezi i naknade Dodano
apps/erpnext/erpnext/assets/doctype/asset/asset.py +214,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Redosled amortizacije {0}: Sledeći datum amortizacije ne može biti pre datuma raspoloživog za upotrebu
,Sales Funnel,Tok prodaje (Funnel)
apps/erpnext/erpnext/setup/doctype/company/company.py +53,Abbreviation is mandatory,Skraćenica je obavezno
DocType: Project,Task Progress,zadatak Napredak
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Kolica
DocType: Certified Consultant,GitHub ID,GitHub ID
DocType: Staffing Plan,Total Estimated Budget,Ukupni procijenjeni budžet
,Qty to Transfer,Količina za prijenos
apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Ponude za kupce ili potencijalne kupce.
DocType: Stock Settings,Role Allowed to edit frozen stock,Uloga dopuštenih urediti smrznute zalihe
,Territory Target Variance Item Group-Wise,Teritorij Target varijance artikla Group - Wise
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,All Customer Groups,Sve grupe kupaca
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +155,Accumulated Monthly,akumulirani Mjesečno
DocType: Attendance Request,On Duty,Na dužnosti
apps/erpnext/erpnext/controllers/accounts_controller.py +848,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obavezno. Možda knjigovodstveni zapis nije kreiran za {1} na {2}.
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +51,Staffing Plan {0} already exist for designation {1},Plan zapošljavanja {0} već postoji za oznaku {1}
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +46,Tax Template is mandatory.,Porez Template je obavezno.
apps/erpnext/erpnext/accounts/doctype/account/account.py +51,Account {0}: Parent account {1} does not exist,Konto {0}: Nadređeni konto {1} ne postoji
DocType: POS Closing Voucher,Period Start Date,Datum početka perioda
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Cjenik stopa (Društvo valuta)
DocType: Products Settings,Products Settings,Proizvodi Postavke
,Item Price Stock,Stavka cijena Stock
apps/erpnext/erpnext/config/accounts.py +50,To make Customer based incentive schemes.,Da napravimo šeme podsticajnih zasnovanih na kupcima.
DocType: Lab Prescription,Test Created,Test Created
DocType: Healthcare Settings,Custom Signature in Print,Prilagođeni potpis u štampi
DocType: Account,Temporary,Privremen
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +120,Customer LPO No.,Korisnički LPO br.
DocType: Amazon MWS Settings,Market Place Account Group,Tržišna grupa računa
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +14,Make Payment Entries,Napravite unos uplate
DocType: Program,Courses,kursevi
DocType: Monthly Distribution Percentage,Percentage Allocation,Postotak Raspodjela
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +116,Secretary,Sekretarica
apps/erpnext/erpnext/regional/india/utils.py +177,House rented dates required for exemption calculation,Iznajmljeni datumi kuće potrebni za izračunavanje izuzeća
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Ako onemogućite, &#39;riječima&#39; polju neće biti vidljivi u bilo koju transakciju"
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +29,This action will stop future billing. Are you sure you want to cancel this subscription?,Ova akcija će zaustaviti buduće obračunavanje. Da li ste sigurni da želite otkazati ovu pretplatu?
DocType: Serial No,Distinct unit of an Item,Različite jedinice strane jedinice
DocType: Supplier Scorecard Criteria,Criteria Name,Ime kriterijuma
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1387,Please set Company,Molimo podesite Company
DocType: Procedure Prescription,Procedure Created,Kreiran postupak
DocType: Pricing Rule,Buying,Nabavka
apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Bolesti i đubriva
DocType: HR Settings,Employee Records to be created by,Zaposlenik Records bi se stvorili
DocType: Inpatient Record,AB Negative,AB Negativ
DocType: POS Profile,Apply Discount On,Nanesite popusta na
DocType: Member,Membership Type,Tip članstva
,Reqd By Date,Reqd Po datumu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +147,Creditors,Kreditori
DocType: Assessment Plan,Assessment Name,procjena ime
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +101,Show PDC in Print,Pokažite PDC u Štampanje
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +95,Row # {0}: Serial No is mandatory,Row # {0}: Serial No je obavezno
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Stavka Wise Porezna Detalj
DocType: Employee Onboarding,Job Offer,Ponudu za posao
apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Institut Skraćenica
,Item-wise Price List Rate,Stavka - mudar Cjenovnik Ocijenite
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1149,Supplier Quotation,Dobavljač Ponuda
DocType: Quotation,In Words will be visible once you save the Quotation.,U riječi će biti vidljiv nakon što spremite ponudu.
apps/erpnext/erpnext/utilities/transaction_base.py +158,Quantity ({0}) cannot be a fraction in row {1},Količina ({0}) ne može biti frakcija u nizu {1}
DocType: Contract,Unsigned,Unsigned
DocType: Selling Settings,Each Transaction,Svaka transakcija
apps/erpnext/erpnext/stock/doctype/item/item.py +509,Barcode {0} already used in Item {1},Barkod {0} se već koristi u artiklu {1}
apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Pravila za dodavanjem troškove prijevoza .
DocType: Hotel Room,Extra Bed Capacity,Kapacitet dodatnog ležaja
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +72,Varaiance ,Varaiance
DocType: Item,Opening Stock,otvaranje Stock
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Kupac je obavezan
DocType: Lab Test,Result Date,Datum rezultata
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +100,PDC/LC Date,PDC / LC Datum
DocType: Purchase Order,To Receive,Da Primite
DocType: Leave Period,Holiday List for Optional Leave,List za odmor za opcioni odlazak
apps/erpnext/erpnext/utilities/user_progress.py +252,user@example.com,user@example.com
DocType: Asset,Asset Owner,Vlasnik imovine
DocType: Purchase Invoice,Reason For Putting On Hold,Razlog za stavljanje na čekanje
DocType: Employee,Personal Email,Osobni e
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +86,Total Variance,Ukupno Varijansa
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Ako je omogućeno, sustav će objaviti računovodstvene stavke za popis automatski."
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,posredništvo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +265,Attendance for employee {0} is already marked for this day,Posjećenost za zaposlenog {0} je već označena za ovaj dan
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'","u minutama 
 ažurirano preko 'Time Log'"
DocType: Customer,From Lead,Od Lead-a
DocType: Amazon MWS Settings,Synch Orders,Synch Porudžbine
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Narudžbe objavljen za proizvodnju.
apps/erpnext/erpnext/public/js/account_tree_grid.js +65,Select Fiscal Year...,Odaberite fiskalnu godinu ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +638,POS Profile required to make POS Entry,POS Profil potrebno da bi POS upis
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +15,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.","Točke lojalnosti će se izračunati iz potrošene (preko fakture za prodaju), na osnovu navedenog faktora sakupljanja."
DocType: Program Enrollment Tool,Enroll Students,upisati studenti
DocType: Company,HRA Settings,HRA Settings
DocType: Employee Transfer,Transfer Date,Datum prenosa
DocType: Lab Test,Approved Date,Odobreni datum
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standardna prodaja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +240,Atleast one warehouse is mandatory,Atleast jednom skladištu je obavezno
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py +14,"Configure Item Fields like UOM, Item Group, Description and No of Hours.","Konfigurirajte polja polja kao što su UOM, grupa stavki, opis i broj sati."
DocType: Certification Application,Certification Status,Status certifikacije
apps/erpnext/erpnext/public/js/hub/marketplace.js +45,Marketplace,Tržište
DocType: Travel Itinerary,Travel Advance Required,Potrebno je unaprediti putovanje
DocType: Subscriber,Subscriber Name,Ime pretplatnika
DocType: Serial No,Out of Warranty,Od jamstvo
DocType: Cashier Closing,Cashier-closing-,Blagajna-zatvaranje-
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,Mapped Data Type
DocType: BOM Update Tool,Replace,Zamijeniti
apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Nema proizvoda.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +396,{0} against Sales Invoice {1},{0} protiv prodaje fakture {1}
DocType: Antibiotic,Laboratory User,Laboratorijski korisnik
DocType: Request for Quotation Item,Project Name,Naziv projekta
DocType: Customer,Mention if non-standard receivable account,Spomenuti ako nestandardni potraživanja račun
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +63,Please add the remaining benefits {0} to any of the existing component,Dodajte preostale pogodnosti {0} bilo kojoj od postojećih komponenti
DocType: Journal Entry Account,If Income or Expense,Ako prihoda i rashoda
DocType: Bank Statement Transaction Entry,Matching Invoices,Upoređivanje faktura
DocType: Work Order,Required Items,potrebna Predmeti
DocType: Stock Ledger Entry,Stock Value Difference,Stock Vrijednost razlika
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: {1} {2} does not exist in above '{1}' table,Stavka Red {0}: {1} {2} ne postoji iznad tabele &quot;{1}&quot;
apps/erpnext/erpnext/config/learn.py +229,Human Resource,Human Resource
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Pomirenje Plaćanje Plaćanje
DocType: Disease,Treatment Task,Tretman zadataka
DocType: Payment Order Reference,Bank Account Details,Detalji o bankovnom računu
DocType: Purchase Order Item,Blanket Order,Narudžbina odeće
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +39,Tax Assets,porezna imovina
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +631,Production Order has been {0},Proizvodnja Poretka bio je {0}
apps/erpnext/erpnext/regional/india/utils.py +186,House rent paid days overlap with {0},Plaćeni dani kuća se preklapaju sa {0}
DocType: BOM Item,BOM No,BOM br.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +192,Journal Entry {0} does not have account {1} or already matched against other voucher,Journal Entry {0} nema obzir {1} ili su već usklađene protiv drugih vaučer
DocType: Item,Moving Average,Moving Average
DocType: BOM Update Tool,The BOM which will be replaced,BOM koji će biti zamijenjen
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +47,Electronic Equipments,elektronske opreme
DocType: Asset,Maintenance Required,Potrebno održavanje
DocType: Account,Debit,Zaduženje
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +63,Leaves must be allocated in multiples of 0.5,"Listovi moraju biti dodijeljeno u COMBI 0,5"
DocType: Work Order,Operation Cost,Operacija Cost
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +318,Identifying Decision Makers,Identifikovanje donosilaca odluka
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Outstanding Amt,Izvanredna Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Set cilja predmet Grupa-mudar za ovaj prodavač.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Dionice stariji od [ dana ]
DocType: Payment Request,Payment Ordered,Raspored plaćanja
DocType: Asset Maintenance Team,Maintenance Team Name,Naziv tima za održavanje
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.","Ako su dva ili više Pravila cijene se nalaze na osnovu gore uvjetima, Prioritet se primjenjuje. Prioritet je broj od 0 do 20, a zadana vrijednost je nula (prazno). Veći broj znači da će imati prednost, ako postoji više pravila cijenama s istim uslovima."
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,Korisnik je obavezan ako je izabrana opcija &quot;Opcija od&quot; kao Korisnik
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiskalna godina: {0} ne postoji
DocType: Currency Exchange,To Currency,Valutno
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Dopusti sljedeći korisnici odobriti ostavite aplikacije za blok dana.
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +30,Lifecycle,Životni ciklus
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +142,Make BOM,Napravite BOM
apps/erpnext/erpnext/controllers/selling_controller.py +158,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},stopa za stavke prodaje {0} je niža od {1}. stopa prodaje bi trebao biti atleast {2}
DocType: Subscription,Taxes,Porezi
DocType: Purchase Invoice,capital goods,kapitalna dobra
DocType: Purchase Invoice Item,Weight Per Unit,Težina po jedinici
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +355,Paid and Not Delivered,Platio i nije dostavila
DocType: Project,Default Cost Center,Standard Cost Center
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Stock Transakcije
DocType: Budget,Budget Accounts,računa budžeta
DocType: Employee,Internal Work History,Interni History Work
DocType: Bank Statement Transaction Entry,New Transactions,Nove transakcije
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Ispravka vrijednosti iznos
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Varijabilni pokazatelj dobavljača
apps/erpnext/erpnext/assets/doctype/asset/asset.py +75,Please create purchase receipt or purchase invoice for the item {0},Molimo vas da kreirate račun za kupovinu ili kupite fakturu za stavku {0}
DocType: Employee Advance,Due Advance Amount,Due Advance Amount
DocType: Maintenance Visit,Customer Feedback,Ocjena Kupca
DocType: Account,Expense,rashod
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +42,Score cannot be greater than Maximum Score,Rezultat ne može biti veća od maksimalne Score
DocType: Support Search Source,Source Type,Tip izvora
apps/erpnext/erpnext/utilities/user_progress.py +129,Customers and Suppliers,Kupci i dobavljači
DocType: Item Attribute,From Range,Od Range
DocType: BOM,Set rate of sub-assembly item based on BOM,Postavite brzinu stavke podkomponenta na osnovu BOM-a
DocType: Inpatient Occupancy,Invoiced,Fakturisano
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +179,Syntax error in formula or condition: {0},Sintaksa greška u formuli ili stanja: {0}
DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Svakodnevni rad Pregled Postavke kompanije
apps/erpnext/erpnext/stock/utils.py +149,Item {0} ignored since it is not a stock item,Artikal {0} se ignorira budući da nije skladišni artikal
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.","Da se ne primjenjuje pravilo Cijene u određenoj transakciji, svim primjenjivim pravilima cijena bi trebala biti onemogućen."
DocType: Payment Term,Day(s) after the end of the invoice month,Dan (i) nakon završetka meseca fakture
DocType: Assessment Group,Parent Assessment Group,Parent Procjena Group
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +54,Jobs,Posao
,Sales Order Trends,Prodajnog naloga trendovi
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.,&quot;Od paketa br.&quot; polje ne sme biti prazno niti je vrijednost manja od 1.
DocType: Employee,Held On,Održanoj
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36,Production Item,Proizvodnja Item
,Employee Information,Informacija o zaposlenom
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +242,Healthcare Practitioner not available on {0},Zdravstveni radnik nije dostupan na {0}
DocType: Stock Entry Detail,Additional Cost,Dodatni trošak
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +56,"Can not filter based on Voucher No, if grouped by Voucher","Ne možete filtrirati na temelju vaučer No , ako grupirani po vaučer"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +968,Make Supplier Quotation,Provjerite Supplier kotaciji
DocType: Quality Inspection,Incoming,Dolazni
apps/erpnext/erpnext/setup/doctype/company/company.js +90,Default tax templates for sales and purchase are created.,Osnovani porezni predlošci za prodaju i kupovinu su stvoreni.
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +44,Assessment Result record {0} already exists.,Evidencija Rezultat zapisa {0} već postoji.
DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Primer: ABCD. #####. Ako je serija postavljena i Batch No se ne pominje u transakcijama, na osnovu ove serije će se kreirati automatski broj serije. Ako uvek želite da eksplicitno navedete Batch No za ovu stavku, ostavite ovo praznim. Napomena: ovo podešavanje će imati prioritet nad Prefiksom naziva serije u postavkama zaliha."
DocType: BOM,Materials Required (Exploded),Materijali Obavezno (eksplodirala)
DocType: Contract,Party User,Party User
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',Molimo podesite Company filter prazno ako Skupina Od je &#39;Company&#39;
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +68,Posting Date cannot be future date,Datum knjiženja ne može biti u budućnosti
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +100,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: {1} Serial No ne odgovara {2} {3}
DocType: Stock Entry,Target Warehouse Address,Adresa ciljne magacine
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +89,Casual Leave,Casual dopust
DocType: Agriculture Task,End Day,Krajnji dan
DocType: Batch,Batch ID,ID serije
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +386,Note: {0},Napomena : {0}
,Delivery Note Trends,Trendovi otpremnica
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +120,This Week's Summary,Ovonedeljnom Pregled
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Na skladištu Količina
,Daily Work Summary Replies,Dnevni rad Sumarni odgovori
DocType: Delivery Trip,Calculate Estimated Arrival Times,Izračunajte procenjene vremenske prilike
apps/erpnext/erpnext/accounts/general_ledger.py +113,Account: {0} can only be updated via Stock Transactions,Račun: {0} može ažurirati samo preko Stock Transakcije
DocType: Student Group Creation Tool,Get Courses,Get kursevi
DocType: Shopify Settings,Webhooks,Webhooks
DocType: Bank Account,Party,Stranka
DocType: Healthcare Settings,Patient Name,Ime pacijenta
DocType: Variant Field,Variant Field,Varijantsko polje
apps/erpnext/erpnext/assets/doctype/asset/asset.js +370,Target Location,Ciljna lokacija
DocType: Sales Order,Delivery Date,Datum isporuke
DocType: Opportunity,Opportunity Date,Datum prilike
DocType: Employee,Health Insurance Provider,Zdravstveno osiguranje
DocType: Products Settings,Show Availability Status,Prikaži status dostupnosti
DocType: Purchase Receipt,Return Against Purchase Receipt,Vratiti protiv Kupovina prijem
DocType: Water Analysis,Person Responsible,Odgovorna osoba
DocType: Request for Quotation Item,Request for Quotation Item,Zahtjev za ponudu artikla
DocType: Purchase Order,To Bill,To Bill
DocType: Material Request,% Ordered,% Poruceno
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Za studentske grupe na osnovu Naravno, kurs će biti potvrđeni za svakog studenta iz upisao jezika u upisu Programa."
DocType: Employee Grade,Employee Grade,Razred zaposlenih
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +106,Piecework,rad plaćen na akord
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Avg. Buying Rate,Prosj. Buying Rate
DocType: Share Balance,From No,Od br
DocType: Task,Actual Time (in Hours),Stvarno vrijeme (u satima)
DocType: Employee,History In Company,Povijest tvrtke
DocType: Customer,Customer Primary Address,Primarna adresa klijenta
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Newsletteri
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py +172,Reference No.,Referentni broj
DocType: Drug Prescription,Description/Strength,Opis / snaga
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,Kreirajte novu uplatu / dnevnik
DocType: Certification Application,Certification Application,Aplikacija za sertifikaciju
DocType: Leave Type,Is Optional Leave,Da li je opcioni odlazak?
DocType: Share Balance,Is Company,Je kompanija
DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Stupanje
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +190,{0} on Half day Leave on {1},{0} na pola dana Ostavite na {1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +86,Same item has been entered multiple times,Isto artikal je ušao više puta
DocType: Department,Leave Block List,Ostavite Block List
DocType: Purchase Invoice,Tax ID,Porez ID
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Item {0} is not setup for Serial Nos. Column must be blank,Stavka {0} nije setup za serijski brojevi Stupac mora biti prazan
DocType: Accounts Settings,Accounts Settings,Podešavanja konta
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,odobriti
DocType: Loyalty Program,Customer Territory,Teritorija kupaca
DocType: Email Digest,Sales Orders to Deliver,Prodajna narudžbina za isporuku
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","Broj novog naloga, on će biti uključen u ime računa kao prefiks"
DocType: Maintenance Team Member,Team Member,Član tima
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Nije rezultat koji se šalje
DocType: Customer,Sales Partner and Commission,Prodajnog partnera i Komisije
DocType: Loan,Rate of Interest (%) / Year,Kamatnu stopu (%) / godina
,Project Quantity,projekt Količina
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'","Ukupno {0} za sve stavke je nula, možda biste trebali promijeniti &#39;Rasporedite Optužbe na osnovu&#39;"
apps/erpnext/erpnext/hr/utils.py +152,To date can not be less than from date,Do danas ne može biti manje od datuma
DocType: Opportunity,To Discuss,Za diskusiju
apps/erpnext/erpnext/accounts/doctype/subscriber/subscriber_dashboard.py +6,This is based on transactions against this Subscriber. See timeline below for details,Ovo se zasniva na transakcijama protiv ovog pretplatnika. Za detalje pogledajte vremenski okvir ispod
apps/erpnext/erpnext/stock/stock_ledger.py +378,{0} units of {1} needed in {2} to complete this transaction.,{0} jedinicama {1} potrebno {2} za završetak ove transakcije.
DocType: Loan Type,Rate of Interest (%) Yearly,Kamatnu stopu (%) Godišnji
DocType: Support Settings,Forum URL,Forum URL
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +75,Temporary Accounts,Privremeni računi
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +40,Source Location is required for the asset {0},Izvorna lokacija je potrebna za sredstvo {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Black,Crn
DocType: BOM Explosion Item,BOM Explosion Item,BOM eksplozije artikla
DocType: Shareholder,Contact List,Lista kontakata
DocType: Account,Auditor,Revizor
DocType: Project,Frequency To Collect Progress,Frekvencija za sakupljanje napretka
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +254,{0} items produced,{0} artikala proizvedenih
apps/erpnext/erpnext/utilities/user_progress.py +58,Learn More,Nauči više
DocType: Cheque Print Template,Distance from top edge,Udaljenost od gornje ivice
DocType: POS Closing Voucher Invoices,Quantity of Items,Količina predmeta
apps/erpnext/erpnext/stock/get_item_details.py +521,Price List {0} is disabled or does not exist,Popis Cijena {0} je isključena ili ne postoji
DocType: Purchase Invoice,Return,Povratak
DocType: Pricing Rule,Disable,Ugasiti
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +184,Mode of payment is required to make a payment,Način plaćanja je potrebno izvršiti uplatu
DocType: Project Task,Pending Review,Na čekanju
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Uredite na celoj stranici za više opcija kao što su imovina, serijski nos, serije itd."
DocType: Leave Type,Maximum Continuous Days Applicable,Primenjivi su maksimalni trajni dani
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} nije upisana u Batch {2}
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +118,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} ne može biti ukinuta, jer je već {1}"
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Cheques Required,Potrebni provjeri
DocType: Task,Total Expense Claim (via Expense Claim),Ukupni rashodi potraživanja (preko rashodi potraživanje)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Odsutan
DocType: Job Applicant Source,Job Applicant Source,Izvor aplikanta za posao
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +328,IGST Amount,IGST Iznos
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Nije uspela kompanija podesiti
DocType: Asset Repair,Asset Repair,Popravka imovine
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +152,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Red {0}: Valuta sastavnicu # {1} treba da bude jednaka odabrane valute {2}
DocType: Journal Entry Account,Exchange Rate,Tečaj
DocType: Patient,Additional information regarding the patient,Dodatne informacije o pacijentu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +656,Sales Order {0} is not submitted,Prodajnog naloga {0} nije podnesen
DocType: Homepage,Tag Line,Tag Line
DocType: Fee Component,Fee Component,naknada Komponenta
apps/erpnext/erpnext/config/hr.py +286,Fleet Management,Fleet Management
apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Crop &amp; Lands
DocType: Cheque Print Template,Regular,redovan
DocType: Fertilizer,Density (if liquid),Gustina (ako je tečnost)
apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Ukupno weightage svih Kriteriji ocjenjivanja mora biti 100%
DocType: Purchase Order Item,Last Purchase Rate,Zadnja kupovna cijena
DocType: Account,Asset,Asset
DocType: Project Task,Task ID,Zadatak ID
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Stock ne može postojati za Stavka {0} od ima varijante
DocType: Healthcare Practitioner,Mobile,Mobilni
,Sales Person-wise Transaction Summary,Prodaja Osobne mudar Transakcija Sažetak
DocType: Training Event,Contact Number,Kontakt broj
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73,Warehouse {0} does not exist,Skladište {0} ne postoji
DocType: Cashier Closing,Custody,Starateljstvo
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Group,Dobavljač&gt; Grupa dobavljača
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,Detalji o podnošenju dokaza o izuzeću poreza na radnike
DocType: Monthly Distribution,Monthly Distribution Percentages,Mjesečni Distribucija Procenat
apps/erpnext/erpnext/stock/doctype/batch/batch.py +115,The selected item cannot have Batch,Izabrana stavka ne može imati Batch
DocType: Delivery Note,% of materials delivered against this Delivery Note,% Materijala dostavljenih protiv ove otpremnici
DocType: Asset Maintenance Log,Has Certificate,Ima sertifikat
DocType: Project,Customer Details,Korisnički podaci
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Proverite da li imovina zahteva preventivno održavanje ili kalibraciju
apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,Skraćenica kompanije ne može imati više od 5 znakova
DocType: Employee,Reports to,Izvještaji za
,Unpaid Expense Claim,Neplaćeni Rashodi Preuzmi
DocType: Payment Entry,Paid Amount,Plaćeni iznos
apps/erpnext/erpnext/utilities/user_progress.py +158,Explore Sales Cycle,Istražite kola prodaje
DocType: Assessment Plan,Supervisor,nadzornik
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +944,Retention Stock Entry,Zadržavanje zaliha zaliha
,Available Stock for Packing Items,Raspoloživo stanje za pakirane proizvode
DocType: Item Variant,Item Variant,Stavka Variant
,Work Order Stock Report,Izveštaj o radnom nalogu
DocType: Purchase Receipt,Auto Repeat Detail,Auto Repeat Detail
DocType: Assessment Result Tool,Assessment Result Tool,Procjena Alat Rezultat
apps/erpnext/erpnext/education/doctype/instructor/instructor.js +45,As Supervisor,Kao supervizor
DocType: Leave Policy Detail,Leave Policy Detail,Ostavite detalje o politici
DocType: BOM Scrap Item,BOM Scrap Item,BOM otpad Stavka
apps/erpnext/erpnext/accounts/page/pos/pos.js +906,Submitted orders can not be deleted,Dostavljeni nalozi se ne može izbrisati
apps/erpnext/erpnext/accounts/doctype/account/account.py +121,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Stanje računa već u zaduženje, ne smiju postaviti 'ravnoteža se mora' kao 'kreditne'"
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +360,Quality Management,upravljanja kvalitetom
apps/erpnext/erpnext/assets/doctype/asset/asset.py +52,Item {0} has been disabled,Stavka {0} je onemogućena
DocType: Project,Total Billable Amount (via Timesheets),Ukupan iznos iznosa (preko Timesheeta)
DocType: Agriculture Task,Previous Business Day,Prethodni radni dan
DocType: Loan,Repay Fixed Amount per Period,Otplatiti fiksni iznos po periodu
DocType: Employee,Health Insurance No,Zdravstveno osiguranje br
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,Dokazi o poreznom oslobađanju
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Molimo unesite količinu za točku {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +233,Credit Note Amt,Kredit Napomena Amt
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py +78,Total Taxable Amount,Ukupan iznos oporezivanja
DocType: Employee External Work History,Employee External Work History,Istorija rada zaposlenog izvan preduzeća
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +689,Job card {0} created,Kartica za posao {0} kreirana
DocType: Opening Invoice Creation Tool,Purchase,Kupiti
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Bilans kol
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Ciljevi ne može biti prazan
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +18,Enrolling students,Upis studenata
DocType: Item Group,Parent Item Group,Roditelj artikla Grupa
DocType: Appointment Type,Appointment Type,Tip imenovanja
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} {1} za
DocType: Healthcare Settings,Valid number of days,Veliki broj dana
apps/erpnext/erpnext/setup/doctype/company/company.js +59,Cost Centers,Troška
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +19,Restart Subscription,Restart pretplata
DocType: Linked Plant Analysis,Linked Plant Analysis,Analiza povezanih biljaka
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +358,Transporter ID,ID transportera
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +317,Value Proposition,Value Proposition
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Stopa po kojoj supplier valuta se pretvaraju u tvrtke bazne valute
DocType: Purchase Invoice Item,Service End Date,Datum završetka usluge
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: Timings sukobi s redom {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Dozvolite Zero Vrednovanje Rate
DocType: Bank Guarantee,Receiving,Primanje
DocType: Training Event Employee,Invited,pozvan
apps/erpnext/erpnext/config/accounts.py +346,Setup Gateway accounts.,Podešavanje Gateway račune.
DocType: Employee,Employment Type,Zapošljavanje Tip
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Fixed Assets,Dugotrajna imovina
DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange dobitak / gubitak
,GST Purchase Register,PDV Kupovina Registracija
,Cash Flow,Priliv novca
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Kombinovani deo računa mora biti 100%
DocType: Item Default,Default Expense Account,Zadani račun rashoda
DocType: GST Account,CGST Account,CGST nalog
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student-mail ID
DocType: Employee,Notice (days),Obavijest (dani )
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,POS zaključavanje vaučera
DocType: Tax Rule,Sales Tax Template,Porez na promet Template
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Plaćanje protiv povlastice
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +21,Update Cost Center Number,Ažurirajte broj centra troškova
apps/erpnext/erpnext/accounts/page/pos/pos.js +2521,Select items to save the invoice,Odaberite stavke za spremanje fakture
DocType: Employee,Encashment Date,Encashment Datum
DocType: Training Event,Internet,Internet
DocType: Special Test Template,Special Test Template,Specijalni test šablon
DocType: Account,Stock Adjustment,Stock Podešavanje
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Uobičajeno aktivnosti Troškovi postoji aktivnost Tip - {0}
DocType: Work Order,Planned Operating Cost,Planirani operativnih troškova
DocType: Academic Term,Term Start Date,Term Ozljede Datum
apps/erpnext/erpnext/config/accounts.py +515,List of all share transactions,Spisak svih dionica transakcija
DocType: Supplier,Is Transporter,Je transporter
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,Uvezite fakturu prodaje iz Shopify-a ako je oznaka uplaćena
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,opp Count
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +218,Both Trial Period Start Date and Trial Period End Date must be set,Moraju se podesiti datum početka probnog perioda i datum završetka probnog perioda
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Prosečna stopa
apps/erpnext/erpnext/controllers/accounts_controller.py +792,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Ukupan iznos plaćanja u rasporedu plaćanja mora biti jednak Grand / zaokruženom ukupno
DocType: Subscription Plan Detail,Plan,Plan
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Banka bilans po glavnoj knjizi
DocType: Job Applicant,Applicant Name,Podnositelj zahtjeva Ime
DocType: Authorization Rule,Customer / Item Name,Kupac / Stavka Ime
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","Agregat grupa ** Predmeti ** u drugu ** Stavka **. Ovo je korisno ako se vezanje određenog ** Predmeti ** u paketu i održavanje zaliha na upakovane ** Predmeti ** a ne agregata ** Stavka **. Paket ** ** Stavka će imati &quot;Je Stock Stavka&quot; kao &quot;ne&quot; i &quot;Da li je prodaja Stavka&quot; kao &quot;Da&quot;. Na primjer: Ako se prodaje laptopa i Ruksaci odvojeno i imaju posebnu cijenu ako kupac kupuje obje, onda Laptop + Ruksak će biti novi Bundle proizvoda stavku. Napomena: BOM = Bill of Materials"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Serijski Nema je obvezna za točke {0}
DocType: Item Variant Attribute,Attribute,Atribut
DocType: Staffing Plan Detail,Current Count,Trenutni broj
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Molimo navedite iz / u rasponu
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Otvaranje {0} Stvorena faktura
DocType: Serial No,Under AMC,Pod AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Stavka stopa vrednovanja izračunava se razmatra sletio troškova voucher iznosu
apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Zadane postavke za transakciju prodaje.
DocType: Guardian,Guardian Of ,Guardian Of
DocType: Grading Scale Interval,Threshold,prag
DocType: BOM Update Tool,Current BOM,Trenutni BOM
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32,Balance (Dr - Cr),Balans (Dr - Cr)
apps/erpnext/erpnext/public/js/utils.js +56,Add Serial No,Dodaj serijski broj
DocType: Work Order Item,Available Qty at Source Warehouse,Dostupno Količina na izvoru Skladište
apps/erpnext/erpnext/config/support.py +22,Warranty,garancija
DocType: Purchase Invoice,Debit Note Issued,Debit Napomena Zadani
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +60,Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,Filter baziran na Centru za troškove primjenjuje se samo ako je Budget Against izabran kao Cost Center
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1182,"Search by item code, serial number, batch no or barcode","Pretraga po kodu stavke, serijskom broju, broju serije ili barkodu"
DocType: Work Order,Warehouses,Skladišta
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +19,{0} asset cannot be transferred,{0} imovine ne može se prenositi
DocType: Hotel Room Pricing,Hotel Room Pricing,Hotelska soba Pricing
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py +121,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}","Ne mogu označiti zapis hroničnih bolesti ispuštenih, postoje neobračunane fakture {0}"
DocType: Subscription,Days Until Due,Dani do dospijeća
apps/erpnext/erpnext/stock/doctype/item/item.js +82,This Item is a Variant of {0} (Template).,Ovaj artikal je varijanta {0} (Template).
DocType: Workstation,per hour,na sat
DocType: Blanket Order,Purchasing,Nabava
DocType: Announcement,Announcement,objava
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +108,Customer LPO,Korisnički LPO
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Za studentske grupe Batch bazi Studentskog Batch će biti potvrđeni za svakog studenta iz Upis Programa.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Skladište se ne može izbrisati , kao entry stock knjiga postoji za to skladište ."
apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Distribucija
DocType: Journal Entry Account,Loan,Loan
DocType: Expense Claim Advance,Expense Claim Advance,Advance Expense Claim
DocType: Lab Test,Report Preference,Prednost prijave
apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Volonterske informacije.
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +121,Project Manager,Menadzer projekata
,Quoted Item Comparison,Citirano Stavka Poređenje
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Preklapanje u bodovima između {0} i {1}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +356,Dispatch,Otpremanje
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +75,Max discount allowed for item: {0} is {1}%,Maksimalni popust dopušteno za predmet: {0} je {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +191,Net Asset value as on,Neto vrijednost imovine kao i na
DocType: Crop,Produce,Proizvesti
DocType: Hotel Settings,Default Taxes and Charges,Uobičajeno Porezi i naknadama
DocType: Account,Receivable,potraživanja
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +319,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Nije dozvoljeno da se promijeniti dobavljača kao narudžbenicu već postoji
DocType: Stock Entry,Material Consumption for Manufacture,Potrošnja materijala za proizvodnju
DocType: Item Alternative,Alternative Item Code,Alternativni kod artikla
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Uloga koja je dopušteno podnijeti transakcije koje premašuju kreditnih ograničenja postavljena.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1065,Select Items to Manufacture,Odaberi stavke za proizvodnju
DocType: Delivery Stop,Delivery Stop,Dostava Stop
apps/erpnext/erpnext/accounts/page/pos/pos.js +974,"Master data syncing, it might take some time","Master podataka sinhronizaciju, to bi moglo da potraje"
DocType: Item,Material Issue,Materijal Issue
DocType: Employee Education,Qualification,Kvalifikacija
DocType: Item Price,Item Price,Cijena artikla
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Sapun i deterdžent
DocType: BOM,Show Items,Pokaži Predmeti
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Od vremena ne može biti veća nego vremena.
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +111,Do you want to notify all the customers by email?,Želite li obavijestiti sve kupce putem e-pošte?
DocType: Subscription Plan,Billing Interval,Interval zaračunavanja
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,Naručeno
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +76,Actual start date and actual end date is mandatory,Datum stvarnog početka i stvarni datum završetka su obavezni
DocType: Salary Detail,Component,sastavni
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +16,Row {0}: {1} must be greater than 0,Red {0}: {1} mora biti veći od 0
DocType: Assessment Criteria,Assessment Criteria Group,Kriteriji procjene Group
DocType: Healthcare Settings,Patient Name By,Ime pacijenta
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +220,Accrual Journal Entry for salaries from {0} to {1},Unos teksta na obračun za plate od {0} do {1}
DocType: Sales Invoice Item,Enable Deferred Revenue,Omogućite odloženi prihod
apps/erpnext/erpnext/assets/doctype/asset/asset.py +193,Opening Accumulated Depreciation must be less than equal to {0},Otvaranje Ispravka vrijednosti mora biti manji od jednak {0}
DocType: Warehouse,Warehouse Name,Naziv skladišta
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py +20,Actual start date must be less than actual end date,Stvarni datum početka mora biti manji od trenutnog datuma završetka
DocType: Naming Series,Select Transaction,Odaberite transakciju
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Unesite Odobravanje ulogu ili Odobravanje korisnike
DocType: Journal Entry,Write Off Entry,Napišite Off Entry
DocType: BOM,Rate Of Materials Based On,Stopa materijali na temelju
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ako je omogućeno, polje Akademski termin će biti obavezno u alatu za upisivanje programa."
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Podrska za Analitiku
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +103,Uncheck all,Poništi sve
DocType: POS Profile,Terms and Conditions,Odredbe i uvjeti
DocType: Asset,Booked Fixed Asset,Rezervisana osnovna sredstva
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},Za datum mora biti unutar fiskalne godine. Pod pretpostavkom da bi datum = {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Ovdje možete održavati visina, težina, alergije, medicinske brige itd."
DocType: Leave Block List,Applies to Company,Odnosi se na preduzeće
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +222,Cannot cancel because submitted Stock Entry {0} exists,"Ne mogu otkazati , jer podnijela Stock Stupanje {0} postoji"
DocType: Loan,Disbursement Date,datuma isplate
DocType: BOM Update Tool,Update latest price in all BOMs,Ažurirajte najnoviju cenu u svim BOM
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +24,Medical Record,Medicinski zapis
DocType: Vehicle,Vehicle,vozilo
DocType: Purchase Invoice,In Words,Riječima
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +21,Enter the name of the bank or lending institution before submittting.,Pre podnošenja navedite ime banke ili kreditne institucije.
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} moraju biti dostavljeni
DocType: POS Profile,Item Groups,stavka grupe
apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Today is {0}'s birthday!,Danas je {0} 's rođendan!
DocType: Sales Order Item,For Production,Za proizvodnju
DocType: Payment Request,payment_url,payment_url
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,Balans u valuti računa
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +188,Please add a Temporary Opening account in Chart of Accounts,Molimo da dodate račun za privremeni otvaranje na kontnom planu
DocType: Customer,Customer Primary Contact,Primarni kontakt klijenta
DocType: Project Task,View Task,Pogledaj Task
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Lead%
DocType: Bank Guarantee,Bank Account Info,Informacije o bankovnom računu
DocType: Bank Guarantee,Bank Guarantee Type,Tip garancije banke
DocType: Payment Schedule,Invoice Portion,Portfelj fakture
,Asset Depreciations and Balances,Imovine Amortizacija i vage
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +372,Amount {0} {1} transferred from {2} to {3},Broj {0} {1} je prešao iz {2} u {3}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +200,{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0} nema raspored zdravstvenih radnika. Dodajte ga u Master Health Practitioner
DocType: Sales Invoice,Get Advances Received,Kreiraj avansno primanje
DocType: Email Digest,Add/Remove Recipients,Dodaj / ukloni primaoce
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Za postavljanje ove fiskalne godine kao zadano , kliknite na "" Set as Default '"
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +130,Amount of TDS Deducted,Iznos TDS odbijen
DocType: Production Plan,Include Subcontracted Items,Uključite predmete sa podugovaračima
apps/erpnext/erpnext/projects/doctype/project/project.py +281,Join,pristupiti
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Nedostatak Qty
apps/erpnext/erpnext/stock/doctype/item/item.py +772,Item variant {0} exists with same attributes,Stavka varijanta {0} postoji sa istim atributima
DocType: Loan,Repay from Salary,Otplatiti iz Plata
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +405,Requesting payment against {0} {1} for amount {2},Tražeći isplatu protiv {0} {1} za iznos {2}
DocType: Additional Salary,Salary Slip,Plaća proklizavanja
DocType: Lead,Lost Quotation,Lost Ponuda
apps/erpnext/erpnext/utilities/user_progress.py +221,Student Batches,Studentske grupe
DocType: Pricing Rule,Margin Rate or Amount,Margina Rate ili iznos
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,' Do datuma ' je obavezno
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generirajte pakovanje Slips za pakete dostaviti. Koristi se za obavijesti paket broja, sadržaj paket i njegove težine."
apps/erpnext/erpnext/projects/doctype/project/project.py +90,Task weight cannot be negative,Težina zadatka ne može biti negativna
DocType: Sales Invoice Item,Sales Order Item,Stavka narudžbe kupca
DocType: Salary Slip,Payment Days,Plaćanja Dana
DocType: Stock Settings,Convert Item Description to Clean HTML,Pretvoriti stavku Opis za čišćenje HTML-a
DocType: Patient,Dormant,skriven
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,Odbitak poreza za neprocenjive koristi zaposlenima
DocType: Salary Slip,Total Interest Amount,Ukupan iznos kamate
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124,Warehouses with child nodes cannot be converted to ledger,Skladišta s djecom čvorovi se ne može pretvoriti u Ledger
DocType: BOM,Manage cost of operations,Upravljanje troškove poslovanja
DocType: Accounts Settings,Stale Days,Zastareli dani
DocType: Travel Itinerary,Arrival Datetime,Dolazak Datetime
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.","Kada bilo koji od provjerenih transakcija &quot;Postavio&quot;, e-mail pop-up automatski otvorio poslati e-mail na povezane &quot;Kontakt&quot; u toj transakciji, s transakcijom u privitku. Korisnik može ili ne može poslati e-mail."
DocType: Tax Rule,Billing Zipcode,Zipcode za naplatu
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-YYYY.-
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globalne postavke
DocType: Crop,Row Spacing UOM,Razmak redova UOM
DocType: Assessment Result Detail,Assessment Result Detail,Procjena Rezultat Detail
DocType: Employee Education,Employee Education,Obrazovanje zaposlenog
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Duplikat stavka grupa naći u tabeli stavka grupa
apps/erpnext/erpnext/public/js/controllers/transaction.js +1180,It is needed to fetch Item Details.,Potrebno je da se donese Stavka Detalji.
DocType: Fertilizer,Fertilizer Name,Ime đubriva
DocType: Salary Slip,Net Pay,Neto plaća
DocType: Cash Flow Mapping Accounts,Account,Konto
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} has already been received,Serijski Ne {0} već je primila
,Requested Items To Be Transferred,Traženi stavki za prijenos
DocType: Expense Claim,Vehicle Log,vozilo se Prijavite
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,Akcija ako se akumulirani mesečni budžet premašuje na aktuelnom nivou
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Napravite odvojeni ulaz za plaćanje protiv potraživanja za naknadu štete
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prisustvo groznice (temperatura&gt; 38,5 ° C / 101,3 ° F ili trajna temperatura&gt; 38 ° C / 100,4 ° F)"
DocType: Customer,Sales Team Details,Prodaja Team Detalji
apps/erpnext/erpnext/accounts/page/pos/pos.js +1366,Delete permanently?,Obrisati trajno?
DocType: Expense Claim,Total Claimed Amount,Ukupno Zatražio Iznos
apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potencijalne prilike za prodaju.
DocType: Shareholder,Folio no.,Folio br.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +251,Invalid {0},Invalid {0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +93,Sick Leave,Bolovanje
DocType: Email Digest,Email Digest,E-pošta
DocType: Delivery Note,Billing Address Name,Naziv adrese za naplatu
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Robne kuće
,Item Delivery Date,Datum isporuke artikla
DocType: Selling Settings,Sales Update Frequency,Frekvencija ažuriranja prodaje
DocType: Production Plan,Material Requested,Zahtevani materijal
DocType: Warehouse,PIN,PIN
DocType: Bin,Reserved Qty for sub contract,Rezervisana količina za pod ugovorom
DocType: Patient Service Unit,Patinet Service Unit,Patinet Service Unit
DocType: Sales Invoice,Base Change Amount (Company Currency),Base Promijeni Iznos (Company Valuta)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +309,No accounting entries for the following warehouses,Nema računovodstvene unosi za sljedeće skladišta
apps/erpnext/erpnext/projects/doctype/project/project.js +98,Save the document first.,Spremite dokument prvi.
apps/erpnext/erpnext/shopping_cart/cart.py +74,Only {0} in stock for item {1},Samo {0} u zalihi za stavku {1}
DocType: Account,Chargeable,Naplativ
DocType: Company,Change Abbreviation,Promijeni Skraćenica
DocType: Contract,Fulfilment Details,Ispunjavanje Detalji
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +68,Pay {0} {1},Plaćajte {0} {1}
DocType: Employee Onboarding,Activities,Aktivnosti
DocType: Expense Claim Detail,Expense Date,Rashodi Datum
DocType: Item,No of Months,Broj meseci
DocType: Item,Max Discount (%),Max rabat (%)
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Kreditni dani ne mogu biti negativni broj
DocType: Purchase Invoice Item,Service Stop Date,Datum zaustavljanja usluge
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Last Order Iznos
DocType: Cash Flow Mapper,e.g Adjustments for:,npr. prilagođavanja za:
apps/erpnext/erpnext/stock/doctype/item/item.py +290," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Zadržavanje uzorka je zasnovano na seriji, molimo vas da proverite da li je serija ne da zadržite uzorak stavke"
DocType: Task,Is Milestone,je Milestone
DocType: Certification Application,Yet to appear,Još uvek se pojavljuje
DocType: Delivery Stop,Email Sent To,E-mail poslat
DocType: Job Card Item,Job Card Item,Stavka za karticu posla
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,Dozvoli Centru za troškove prilikom unosa računa bilansa stanja
apps/erpnext/erpnext/accounts/doctype/account/account.js +102,Merge with Existing Account,Spoji se sa postojećim računom
DocType: Budget,Warn,Upozoriti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +988,All items have already been transferred for this Work Order.,Svi predmeti su već preneti za ovaj radni nalog.
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Bilo koji drugi primjedbe, napomenuti napor koji treba da ide u evidenciji."
DocType: Asset Maintenance,Manufacturing User,Proizvodnja korisnika
DocType: Purchase Invoice,Raw Materials Supplied,Sirovine nabavlja
DocType: Subscription Plan,Payment Plan,Plan placanja
DocType: Shopping Cart Settings,Enable purchase of items via the website,Omogućite kupovinu stavki putem web stranice
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +291,Currency of the price list {0} must be {1} or {2},Valuta cenovnika {0} mora biti {1} ili {2}
apps/erpnext/erpnext/config/accounts.py +532,Subscription Management,Upravljanje pretplatama
DocType: Appraisal,Appraisal Template,Procjena Predložak
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +255,To Pin Code,Za Pin kod
DocType: Soil Texture,Ternary Plot,Ternary plot
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,Proverite ovo da biste omogućili planiranu dnevnu sinhronizaciju rutine preko rasporeda
DocType: Item Group,Item Classification,Stavka Klasifikacija
DocType: Driver,License Number,Broj licence
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Business Development Manager,Business Development Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Svrha posjete za odrzavanje
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Registracija računa pacijenta
DocType: Crop,Period,Period
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27,General Ledger,Glavna knjiga
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +16,To Fiscal Year,Do fiskalne godine
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Pogledaj potencijalne kupce
DocType: Program Enrollment Tool,New Program,novi program
DocType: Item Attribute Value,Attribute Value,Vrijednost atributa
DocType: POS Closing Voucher Details,Expected Amount,Očekivani iznos
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js +16,Create Multiple,Kreiraj više
,Itemwise Recommended Reorder Level,Itemwise Preporučio redoslijeda Level
apps/erpnext/erpnext/hr/utils.py +211,Employee {0} of grade {1} have no default leave policy,Zaposleni {0} razreda {1} nemaju nikakvu politiku za odlazni odmor
DocType: Salary Detail,Salary Detail,Plaća Detail
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103,Please select {0} first,Odaberite {0} Prvi
apps/erpnext/erpnext/public/js/hub/marketplace.js +177,Added {0} users,Dodao je {0} korisnike
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +21,"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent","U slučaju višeslojnog programa, Korisnici će automatski biti dodeljeni za dotičnu grupu po njihovom trošenju"
DocType: Appointment Type,Physician,Lekar
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1072,Batch {0} of Item {1} has expired.,Batch {0} od {1} Stavka je istekla.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Konsultacije
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py +36,Finished Good,Finished Good
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +56,"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.","Stavka Cena se pojavljuje više puta na osnovu Cenovnika, dobavljača / kupca, valute, stavke, UOM, kola i datuma."
DocType: Sales Invoice,Commission,Provizija
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +203,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0} ({1}) ne može biti veća od planirane količine ({2}) u radnom nalogu {3}
DocType: Certification Application,Name of Applicant,Ime podnosioca zahteva
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Time Sheet za proizvodnju.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,suma stavke
apps/erpnext/erpnext/stock/doctype/item/item.py +711,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,Ne mogu promijeniti svojstva varijante nakon transakcije sa akcijama. Za to ćete morati napraviti novu stavku.
apps/erpnext/erpnext/config/integrations.py +18,GoCardless SEPA Mandate,GoCardless SEPA Mandat
DocType: Healthcare Practitioner,Charges,Naknade
DocType: Production Plan,Get Items For Work Order,Dobijte stavke za radni nalog
DocType: Salary Detail,Default Amount,Zadani iznos
DocType: Lab Test Template,Descriptive,Deskriptivno
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +96,Warehouse not found in the system,Skladište nije pronađeno u sistemu
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +123,This Month's Summary,Ovaj mjesec je sažetak
DocType: Quality Inspection Reading,Quality Inspection Reading,Kvaliteta Inspekcija čitanje
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,`blokiraj zalihe starije od podrazumijevanog manje od % d dana .
DocType: Tax Rule,Purchase Tax Template,Porez na promet Template
apps/erpnext/erpnext/utilities/user_progress.py +48,Set a sales goal you'd like to achieve for your company.,Postavite cilj prodaje koji želite ostvariti za svoju kompaniju.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1549,Healthcare Services,Zdravstvene usluge
,Project wise Stock Tracking,Supervizor pracenje zaliha
DocType: GST HSN Code,Regional,regionalni
apps/erpnext/erpnext/config/healthcare.py +50,Laboratory,Laboratorija
DocType: UOM Category,UOM Category,Kategorija UOM
DocType: Clinical Procedure Item,Actual Qty (at source/target),Stvarna kol (na izvoru/cilju)
DocType: Item Customer Detail,Ref Code,Ref. Šifra
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Korisnička grupa je potrebna u POS profilu
DocType: HR Settings,Payroll Settings,Postavke plaće
apps/erpnext/erpnext/config/accounts.py +169,Match non-linked Invoices and Payments.,Klađenje na ne-povezane faktura i plaćanja.
DocType: POS Settings,POS Settings,POS Settings
apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Place Order
DocType: Email Digest,New Purchase Orders,Novi narudžbenice kupnje
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +26,Root cannot have a parent cost center,Korijen ne mogu imati središte troškova roditelj
apps/erpnext/erpnext/public/js/stock_analytics.js +54,Select Brand...,Odaberite Marka ...
apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Neprofitna (beta)
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +167,Accumulated Depreciation as on,Ispravka vrijednosti kao na
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,Kategorija oslobađanja od poreza na zaposlene
DocType: Sales Invoice,C-Form Applicable,C-obrascu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},Vrijeme rada mora biti veći od 0 za rad {0}
DocType: Support Search Source,Post Route String,Post String niz
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +105,Warehouse is mandatory,Skladište je obavezno
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +72,Failed to create website,Neuspelo je kreirati web stranicu
DocType: Soil Analysis,Mg/K,Mg / K
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM pretvorbe Detalj
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +999,Retention Stock Entry already created or Sample Quantity not provided,Već stvoreni unos zadržavanja zaliha ili količina uzorka nisu obezbeđeni
DocType: Program,Program Abbreviation,program Skraćenica
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,Production Order cannot be raised against a Item Template,Proizvodnja Nalog ne može biti podignuta protiv Item Template
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Naknade se ažuriraju u Kupovina Prijem protiv svaku stavku
DocType: Warranty Claim,Resolved By,Riješen Do
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js +32,Schedule Discharge,Raspoređivanje rasporeda
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Čekovi i depoziti pogrešno spašava
apps/erpnext/erpnext/accounts/doctype/account/account.py +53,Account {0}: You can not assign itself as parent account,Konto {0}: Ne može se označiti kao nadređeni konto samom sebi
DocType: Purchase Invoice Item,Price List Rate,Cjenik Stopa
apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Napravi citati kupac
apps/erpnext/erpnext/public/js/controllers/transaction.js +812,Service Stop Date cannot be after Service End Date,Servisni datum zaustavljanja ne može biti nakon datuma završetka usluge
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Show &quot;na lageru&quot; ili &quot;Nije u skladištu&quot; temelji se na skladištu dostupna u tom skladištu.
apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Sastavnice (BOM)
DocType: Item,Average time taken by the supplier to deliver,Prosječno vrijeme koje je dobavljač isporuči
DocType: Travel Itinerary,Check-in Date,Datum dolaska
DocType: Sample Collection,Collected By,Prikupljeno od strane
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +25,Assessment Result,procjena rezultata
DocType: Hotel Room Package,Hotel Room Package,Paket za hotelsku sobu
DocType: Employee Transfer,Employee Transfer,Transfer radnika
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Sati
DocType: Project,Expected Start Date,Očekivani datum početka
DocType: Purchase Invoice,04-Correction in Invoice,04-Ispravka u fakturi
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1038,Work Order already created for all items with BOM,Radni nalog već je kreiran za sve predmete sa BOM
DocType: Payment Request,Party Details,Party Detalji
apps/erpnext/erpnext/stock/doctype/item/item.js +62,Variant Details Report,Varijanta Detalji Izveštaj
DocType: Setup Progress Action,Setup Progress Action,Setup Progress Action
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +42,Buying Price List,Kupovni cjenovnik
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Uklonite stavku ako naknada nije primjenjiv na tu stavku
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +9,Cancel Subscription,Otkaži pretplatu
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Izaberite stanje održavanja kao završeno ili uklonite datum završetka
DocType: Supplier,Default Payment Terms Template,Podrazumevani obrazac za plaćanje
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +40,Transaction currency must be same as Payment Gateway currency,Transakcija valuta mora biti isti kao i Payment Gateway valutu
DocType: Payment Entry,Receive,Primiti
DocType: Employee Benefit Application Detail,Earning Component,Zarađivačka komponenta
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Citati:
DocType: Contract,Partially Fulfilled,Delimično ispunjeno
DocType: Maintenance Visit,Fully Completed,Potpuno Završeni
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Zavrsen
DocType: Employee,Educational Qualification,Obrazovne kvalifikacije
DocType: Workstation,Operating Costs,Operativni troškovi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +487,Currency for {0} must be {1},Valuta za {0} mora biti {1}
DocType: Asset,Disposal Date,odlaganje Datum
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.","E će biti poslana svim aktivnih radnika kompanije u datom sat, ako nemaju odmor. Sažetak odgovora će biti poslan u ponoć."
DocType: Employee Leave Approver,Employee Leave Approver,Osoba koja odobrava izlaske zaposlenima
apps/erpnext/erpnext/stock/doctype/item/item.py +527,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Unos Ponovno red već postoji za to skladište {1}
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Ne može proglasiti izgubili , jer citat je napravio ."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,CWIP Account,CWIP nalog
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,trening Feedback
apps/erpnext/erpnext/config/accounts.py +211,Tax Withholding rates to be applied on transactions.,Poreske stope zadržavanja poreza na transakcije.
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kriterijumi za ocenjivanje dobavljača
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Molimo odaberite datum početka i datum završetka za točke {0}
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-YYYY.-
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Kurs je obavezno u redu {0}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Do danas ne može biti prije od datuma
DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DOCTYPE
DocType: Cash Flow Mapper,Section Footer,Segment Footer
apps/erpnext/erpnext/stock/doctype/item/item.js +353,Add / Edit Prices,Dodaj / Uredi cijene
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py +19,Employee Promotion cannot be submitted before Promotion Date ,Promocija zaposlenih ne može se podneti pre datuma promocije
DocType: Batch,Parent Batch,roditelja Batch
DocType: Cheque Print Template,Cheque Print Template,Ček Ispis Template
DocType: Salary Component,Is Flexible Benefit,Je fleksibilna korist
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +85,Chart of Cost Centers,Grafikon troškovnih centara
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,Broj dana od dana kada je faktura protekla prije otkazivanja pretplate ili obilježavanja pretplate kao neplaćenog
DocType: Clinical Procedure Template,Sample Collection,Prikupljanje uzoraka
,Requested Items To Be Ordered,Traženi Proizvodi se mogu naručiti
DocType: Price List,Price List Name,Cjenik Ime
DocType: Delivery Stop,Dispatch Information,Informacije o otpremi
DocType: Blanket Order,Manufacturing,Proizvodnja
,Ordered Items To Be Delivered,Naručeni proizvodi za dostavu
DocType: Account,Income,Prihod
DocType: Industry Type,Industry Type,Industrija Tip
apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Nešto nije bilo u redu!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +174,Warning: Leave application contains following block dates,Upozorenje: Ostavite program sadrži sljedeće blok datume
DocType: Bank Statement Settings,Transaction Data Mapping,Mapiranje podataka o transakcijama
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +277,Sales Invoice {0} has already been submitted,Prodajni računi {0} su već potvrđeni
DocType: Salary Component,Is Tax Applicable,Da li se porez primenjuje
DocType: Supplier Scorecard Scoring Criteria,Score,skor
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Fiskalna godina {0} ne postoji
DocType: Asset Maintenance Log,Completion Date,Završetak Datum
DocType: Purchase Invoice Item,Amount (Company Currency),Iznos (valuta preduzeća)
DocType: Agriculture Analysis Criteria,Agriculture User,Korisnik poljoprivrede
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Vrijedi do datuma ne može biti prije datuma transakcije
apps/erpnext/erpnext/stock/stock_ledger.py +382,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jedinicama {1} potrebno {2} na {3} {4} za {5} da završi ovu transakciju.
DocType: Fee Schedule,Student Category,student Kategorija
DocType: Announcement,Student,student
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js +98,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Procedura započinjanja količine zaliha nije dostupna u skladištu. Da li želite da zabeležite transfer novca?
DocType: Shipping Rule,Shipping Rule Type,Tip pravila isporuke
apps/erpnext/erpnext/utilities/user_progress.py +239,Go to Rooms,Idite u Sobe
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +259,"Company, Payment Account, From Date and To Date is mandatory","Kompanija, račun za plaćanje, od datuma i do datuma je obavezan"
DocType: Company,Budget Detail,Proračun Detalj
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Unesite poruku prije slanja
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLICATE ZA SUPPLIER
DocType: Asset,Custodian,Skrbnik
apps/erpnext/erpnext/config/accounts.py +356,Point-of-Sale Profile,Point-of-prodaju profil
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25,{0} should be a value between 0 and 100,{0} treba da bude vrednost između 0 i 100
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +319,Payment of {0} from {1} to {2},Isplata {0} od {1} do {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Unsecured Loans,unsecured krediti
DocType: Cost Center,Cost Center Name,Troška Name
DocType: Student,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Maksimalni radni sati protiv Timesheet
DocType: Maintenance Schedule Detail,Scheduled Date,Planski datum
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +232,Total Paid Amt,Ukupno Paid Amt
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Poruka veća od 160 karaktera će biti odvojena u više poruka
DocType: Purchase Receipt Item,Received and Accepted,Primljeni i prihvaćeni
,GST Itemised Sales Register,PDV Specificirane prodaje Registracija
DocType: Staffing Plan,Staffing Plan Details,Detalji o kadrovskom planu
DocType: Soil Texture,Silt Loam,Silt Loam
,Serial No Service Contract Expiry,Serijski Bez isteka Ugovor o pružanju usluga
DocType: Employee Health Insurance,Employee Health Insurance,Zdravstveno osiguranje zaposlenih
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +331,You cannot credit and debit same account at the same time,Ne možete kreditnim i debitnim isti račun u isto vrijeme
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Stopa pulsa odraslih je između 50 i 80 otkucaja u minuti.
DocType: Naming Series,Help HTML,HTML pomoć
DocType: Student Group Creation Tool,Student Group Creation Tool,Student Group Creation Tool
DocType: Item,Variant Based On,Varijanta na osnovu
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Ukupno bi trebalo biti dodijeljena weightage 100 % . To je {0}
DocType: Loyalty Point Entry,Loyalty Program Tier,Nivo programa lojalnosti
apps/erpnext/erpnext/utilities/user_progress.py +109,Your Suppliers,Vaši dobavljači
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,Ne mogu se postaviti kao izgubljen kao prodajnog naloga je napravio .
DocType: Request for Quotation Item,Supplier Part No,Dobavljač dio br
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +395,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Ne mogu odbiti kada kategorija je za &#39;Vrednovanje&#39; ili &#39;Vaulation i Total&#39;
apps/erpnext/erpnext/public/js/hub/components/reviews.js +2,Anonymous,Anonimno
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Received From,Dobili od
DocType: Lead,Converted,Pretvoreno
DocType: Item,Has Serial No,Ima serijski br
DocType: Employee,Date of Issue,Datum izdavanja
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +250,"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}","Prema Kupnja Postavke ako Kupovina Reciept željeni == &#39;DA&#39;, onda za stvaranje fakturi, korisnik treba prvo stvoriti račun za prodaju za stavku {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +172,Row #{0}: Set Supplier for item {1},Row # {0}: Set dobavljač za stavku {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: Hours value must be greater than zero.,Red {0}: Radno vrijednost mora biti veća od nule.
apps/erpnext/erpnext/stock/doctype/item/item.py +210,Website Image {0} attached to Item {1} cannot be found,Sajt Slika {0} prilogu Stavka {1} ne može biti pronađena
DocType: Issue,Content Type,Vrsta sadržaja
DocType: Asset,Assets,Imovina
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Računar
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +212,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Molimo postavite Naming Series za {0} preko Setup&gt; Settings&gt; Series Naming
DocType: Item,List this Item in multiple groups on the website.,Popis ovaj predmet u više grupa na web stranici.
DocType: Subscription,Current Invoice End Date,Trenutni datum završetka računa
DocType: Payment Term,Due Date Based On,Due Date Based On
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82,Please set default customer group and territory in Selling Settings,Molimo podesite podrazumevanu grupu korisnika i teritoriju u prodajnom podešavanju
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +215,{0} {1} does not exist,{0} {1} ne postoji
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +355,Please check Multi Currency option to allow accounts with other currency,Molimo provjerite Multi opciju valuta kako bi se omogućilo račune sa drugoj valuti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88,Item: {0} does not exist in the system,Detaljnije: {0} ne postoji u sustavu
apps/erpnext/erpnext/accounts/doctype/account/account.py +113,You are not authorized to set Frozen value,Niste ovlašteni za postavljanje Frozen vrijednost
DocType: Payment Reconciliation,Get Unreconciled Entries,Kreiraj neusklađene ulaze
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,Employee {0} is on Leave on {1},Zaposleni {0} je na {1}
apps/erpnext/erpnext/hr/doctype/loan/loan.py +159,No repayments selected for Journal Entry,Za unos novina nije izabrana otplata
DocType: Payment Reconciliation,From Invoice Date,Iz Datum računa
DocType: Loan,Disbursed,Isplaćeno
DocType: Healthcare Settings,Laboratory Settings,Laboratorijske postavke
DocType: Clinical Procedure,Service Unit,Servisna jedinica
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Uspešno postavite dobavljača
DocType: Leave Encashment,Leave Encashment,Ostavite unovčenja
apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Što učiniti ?
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +47,Tasks have been created for managing the {0} disease (on row {1}),Zadaci su kreirani za upravljanje {0} bolesti (na redu {1})
DocType: Crop,Byproducts,Podbrojevi
apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,Za skladište
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Svi Student Prijemni
,Average Commission Rate,Prosječna stopa komisija
DocType: Share Balance,No of Shares,Broj akcija
DocType: Taxable Salary Slab,To Amount,Do iznosa
apps/erpnext/erpnext/stock/doctype/item/item.py +465,'Has Serial No' can not be 'Yes' for non-stock item,' Ima serijski broj ' ne može biti ' Da ' za artikle bez zalihe
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59,Select Status,Izaberite Status
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +44,Attendance can not be marked for future dates,Gledatelji ne može biti označena za budući datum
DocType: Support Search Source,Post Description Key,Post Opis Ključ
DocType: Pricing Rule,Pricing Rule Help,Cijene Pravilo Pomoć
DocType: School House,House Name,nazivu
DocType: Fee Schedule,Total Amount per Student,Ukupan iznos po učeniku
DocType: Opportunity,Sales Stage,Prodajna scena
DocType: Purchase Taxes and Charges,Account Head,Zaglavlje konta
DocType: Company,HRA Component,HRA komponenta
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +142,Electrical,Električna
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,Dodajte ostatak organizacije kao korisnika. Također možete dodati pozvati kupce da vaš portal dodavanjem iz kontakata
DocType: Stock Entry,Total Value Difference (Out - In),Ukupna vrijednost Razlika (Out - In)
DocType: Grant Application,Requested Amount,Traženi iznos
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Row {0}: Exchange Rate is mandatory,Red {0}: kursa obavezna
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +46,User ID not set for Employee {0},Korisnik ID nije postavljen za zaposlenika {0}
DocType: Vehicle,Vehicle Value,Vrijednost vozila
DocType: Crop Cycle,Detected Diseases,Otkrivene bolesti
DocType: Stock Entry,Default Source Warehouse,Zadano izvorno skladište
DocType: Item,Customer Code,Kupac Šifra
apps/erpnext/erpnext/hr/doctype/employee/employee.py +237,Birthday Reminder for {0},Rođendan Podsjetnik za {0}
DocType: Asset Maintenance Task,Last Completion Date,Zadnji datum završetka
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Dana od posljednje narudžbe
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +436,Debit To account must be a Balance Sheet account,Zaduženja na račun mora biti bilans stanja računa
DocType: Asset,Naming Series,Imenovanje serije
DocType: Vital Signs,Coated,Premazan
apps/erpnext/erpnext/assets/doctype/asset/asset.py +181,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Red {0}: Očekivana vrednost nakon korisnog života mora biti manja od iznosa bruto kupovine
DocType: GoCardless Settings,GoCardless Settings,GoCardless Settings
DocType: Leave Block List,Leave Block List Name,Ostavite popis imena Block
DocType: Certified Consultant,Certification Validity,Validnost sertifikacije
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Datum osiguranje Početak bi trebao biti manji od datuma osiguranje Kraj
DocType: Shopping Cart Settings,Display Settings,Podešavanja izgleda
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock Assets,dionicama u vrijednosti
DocType: Restaurant,Active Menu,Aktivni meni
DocType: Target Detail,Target Qty,Ciljana Kol
apps/erpnext/erpnext/hr/doctype/loan/loan.py +37,Against Loan: {0},Protiv kredita: {0}
DocType: Shopping Cart Settings,Checkout Settings,Plaćanje Postavke
DocType: Student Attendance,Present,Sadašnje
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Otpremnica {0} ne smije biti potvrđena
DocType: Notification Control,Sales Invoice Message,Poruka prodajnog  računa
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Zatvaranje računa {0} mora biti tipa odgovornosti / Equity
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +407,Salary Slip of employee {0} already created for time sheet {1},Plaća listić od zaposlenika {0} već kreirali za vrijeme stanja {1}
DocType: Vehicle Log,Odometer,mjerač za pređeni put
DocType: Production Plan Item,Ordered Qty,Naručena kol
apps/erpnext/erpnext/stock/doctype/item/item.py +802,Item {0} is disabled,Stavka {0} je onemogućeno
DocType: Stock Settings,Stock Frozen Upto,Kataloški Frozen Upto
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1008,BOM does not contain any stock item,BOM ne sadrži nikakve zaliha stavka
DocType: Chapter,Chapter Head,Glava poglavlja
DocType: Payment Term,Month(s) after the end of the invoice month,Mesec (i) nakon kraja mjeseca fakture
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +66,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Struktura plata treba da ima fleksibilnu komponentu (beneficije) za izdavanje naknade
apps/erpnext/erpnext/config/projects.py +24,Project activity / task.,Projektna aktivnost / zadatak.
DocType: Vital Signs,Very Coated,Veoma prevučeni
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),"Samo uticaj na porez (ne mogu tvrditi, ali dio oporezivog prihoda)"
DocType: Vehicle Log,Refuelling Details,Dopuna goriva Detalji
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25,Lab result datetime cannot be before testing datetime,Datetime rezultata laboratorije ne može biti pre testiranja datetime
DocType: POS Profile,Allow user to edit Discount,Dozvolite korisniku da uredi popust
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63,Get customers from,Uzmite kupce
DocType: Purchase Invoice Item,Include Exploded Items,Uključite eksplodirane predmete
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,"Buying must be checked, if Applicable For is selected as {0}","Kupnja treba provjeriti, ako je primjenjivo za odabrano kao {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Rabatt mora biti manji od 100
DocType: Shipping Rule,Restrict to Countries,Ograničiti zemlje
DocType: Shopify Settings,Shared secret,Zajednička tajna
DocType: Amazon MWS Settings,Synch Taxes and Charges,Synch Taxes and Charges
DocType: Purchase Invoice,Write Off Amount (Company Currency),Otpis Iznos (poduzeća Valuta)
DocType: Sales Invoice Timesheet,Billing Hours,Billing Hours
DocType: Project,Total Sales Amount (via Sales Order),Ukupan iznos prodaje (preko prodajnog naloga)
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +529,Default BOM for {0} not found,Uobičajeno sastavnice za {0} nije pronađen
apps/erpnext/erpnext/stock/doctype/item/item.py +531,Row #{0}: Please set reorder quantity,Row # {0}: Molimo set Ponovno redj količinu
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Dodirnite stavke da biste ih dodali ovdje
DocType: Fees,Program Enrollment,Upis program
DocType: Share Transfer,To Folio No,Za Folio No
DocType: Landed Cost Voucher,Landed Cost Voucher,Sleteo Cost vaučera
apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Molimo postavite {0}
apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} je neaktivan student
DocType: Employee,Health Details,Zdravlje Detalji
DocType: Leave Encashment,Encashable days,Encashable days
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +30,To create a Payment Request reference document is required,Za kreiranje plaćanja Zahtjev je potrebno referentni dokument
DocType: Soil Texture,Sandy Clay,Sandy Clay
DocType: Grant Application,Assessment  Manager,Menadžer procjene
DocType: Payment Entry,Allocate Payment Amount,Izdvojiti plaćanja Iznos
DocType: Subscription Plan,Subscription Plan,Plan pretplate
DocType: Employee External Work History,Salary,Plata
DocType: Serial No,Delivery Document Type,Dokument isporuke - tip
DocType: Sales Order,Partly Delivered,Djelomično Isporučeno
DocType: Item Variant Settings,Do not update variants on save,Ne ažurirajte varijante prilikom štednje
DocType: Email Digest,Receivables,Potraživanja
DocType: Lead Source,Lead Source,Izvor potencijalnog kupca
DocType: Customer,Additional information regarding the customer.,Dodatne informacije o kupcu.
DocType: Quality Inspection Reading,Reading 5,Čitanje 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +237,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je povezan sa {2}, ali Party Party je {3}"
DocType: Bank Statement Settings Item,Bank Header,Bank Header
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Pregled laboratorijskih testova
DocType: Hub Users,Hub Users,Korisnici Hub-a
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Održavanje Datum
DocType: Purchase Invoice Item,Rejected Serial No,Odbijen Serijski br
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,datum početka godine ili datum završetka je preklapaju sa {0}. Da bi se izbjegla molimo vas da postavite kompanija
apps/erpnext/erpnext/selling/doctype/customer/customer.py +137,Please mention the Lead Name in Lead {0},Molim vas da navedete Lead Lead u Lead-u {0}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Početak bi trebao biti manji od krajnjeg datuma za točke {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.","Primjer:. ABCD ##### 
 Ako serije je postavljen i serijski broj se ne spominje u transakcijama, a zatim automatski serijski broj će biti kreiran na osnovu ove serije. Ako želite uvijek izričito spomenuti Serial Nos za ovu stavku. ovo ostavite prazno."
DocType: Upload Attendance,Upload Attendance,Upload Attendance
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +640,BOM and Manufacturing Quantity are required,BOM i proizvodnja Količina su potrebne
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +62,Ageing Range 2,Starenje Range 2
DocType: SG Creation Tool Course,Max Strength,Max Snaga
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Instaliranje podešavanja
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-YYYY.-
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +99,No Delivery Note selected for Customer {},Nije odabrana beleška za isporuku za kupca {}
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +17,Employee {0} has no maximum benefit amount,Zaposleni {0} nema maksimalni iznos naknade
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1128,Select Items based on Delivery Date,Izaberite stavke na osnovu datuma isporuke
DocType: Grant Application,Has any past Grant Record,Ima bilo kakav prošli Grant Record
,Sales Analytics,Prodajna analitika
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127,Available {0},Dostupno {0}
,Prospects Engaged But Not Converted,Izgledi Engaged Ali ne pretvaraju
DocType: Manufacturing Settings,Manufacturing Settings,Proizvodnja Settings
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Postavljanje e-pošte
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobile Nema
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +134,Please enter default currency in Company Master,Unesite zadanu valutu u tvrtki Master
DocType: Stock Entry Detail,Stock Entry Detail,Kataloški Stupanje Detalj
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +117,Daily Reminders,Dnevni podsjetnik
apps/erpnext/erpnext/templates/pages/help.html +56,See all open tickets,Pogledajte sve otvorene karte
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js +21,Healthcare Service Unit Tree,Jedinica za zdravstvenu zaštitu
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +273,Product,Proizvod
DocType: Products Settings,Home Page is Products,Početna stranica su proizvodi
,Asset Depreciation Ledger,Asset Amortizacija Ledger
DocType: Salary Structure,Leave Encashment Amount Per Day,Ostavite iznos unosa na dan
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,Za koliko je potrošeno = 1 lojalnost
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,Tax Rule Conflicts with {0},Porez pravilo sukoba sa {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Naziv novog naloga
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Sirovine Isporuka Troškovi
DocType: Selling Settings,Settings for Selling Module,Postavke za prodaju modul
DocType: Hotel Room Reservation,Hotel Room Reservation,Hotelska rezervacija
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +357,Customer Service,Služba za korisnike
DocType: BOM,Thumbnail,Thumbnail
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +207,No contacts with email IDs found.,Nisu pronađeni kontakti sa ID-ima e-pošte.
DocType: Item Customer Detail,Item Customer Detail,Artikal - detalji kupca
DocType: Notification Control,Prompt for Email on Submission of,Pitaj za e-poštu na podnošenje
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +36,Maximum benefit amount of employee {0} exceeds {1},Maksimalan iznos naknade zaposlenog {0} prelazi {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +102,Total allocated leaves are more than days in the period,Ukupno izdvojene Listovi su više od nekoliko dana u razdoblju
DocType: Linked Soil Analysis,Linked Soil Analysis,Linked soil analysis
DocType: Pricing Rule,Percentage,postotak
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Stavka {0} mora bitistock Stavka
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Uobičajeno Work in Progress Skladište
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +83,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Rasporedi za {0} se preklapaju, da li želite da nastavite nakon preskakanja preklapanih slotova?"
apps/erpnext/erpnext/config/accounts.py +326,Default settings for accounting transactions.,Zadane postavke za računovodstvene poslove.
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js +8,Grant Leaves,Grant Leaves
DocType: Restaurant,Default Tax Template,Podrazumevani obrazac poreza
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +71,{0} Students have been enrolled,{0} Studenti su upisani
DocType: Fees,Student Details,Student Detalji
DocType: Purchase Invoice Item,Stock Qty,zalihama Količina
DocType: Contract,Requires Fulfilment,Zahteva ispunjenje
DocType: Loan,Repayment Period in Months,Rok otplate u mjesecima
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Greška: Ne važeći id?
DocType: Naming Series,Update Series Number,Update serije Broj
DocType: Account,Equity,pravičnost
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +79,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: &#39;dobiti i gubitka&#39; tip naloga {2} nije dozvoljeno otvaranje Entry
DocType: Job Offer,Printing Details,Printing Detalji
DocType: Task,Closing Date,Datum zatvaranja
DocType: Sales Order Item,Produced Quantity,Proizvedena količina
DocType: Item Price,Quantity  that must be bought or sold per UOM,Količina koja se mora kupiti ili prodati po UOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Engineer,inženjer
DocType: Employee Tax Exemption Category,Max Amount,Maksimalni iznos
DocType: Journal Entry,Total Amount Currency,Ukupan iznos valute
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Traži Sub skupština
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +199,Item Code required at Row No {0},Kod artikla je potreban u redu broj {0}
DocType: GST Account,SGST Account,SGST nalog
apps/erpnext/erpnext/utilities/user_progress.py +154,Go to Items,Idi na stavke
DocType: Sales Partner,Partner Type,Partner Tip
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +72,Actual,Stvaran
DocType: Restaurant Menu,Restaurant Manager,Restoran menadžer
DocType: Authorization Rule,Customerwise Discount,Customerwise Popust
apps/erpnext/erpnext/config/projects.py +46,Timesheet for tasks.,Timesheet za zadatke.
DocType: Purchase Invoice,Against Expense Account,Protiv Rashodi račun
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +284,Installation Note {0} has already been submitted,Napomena instalacije {0} je već potvrđena
DocType: Bank Reconciliation,Get Payment Entries,Get plaćanja unosi
DocType: Quotation Item,Against Docname,Protiv Docname
DocType: SMS Center,All Employee (Active),Svi zaposleni (aktivni)
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Pregled Sada
DocType: BOM,Raw Material Cost,Troškovi sirovina
DocType: Woocommerce Settings,Woocommerce Server URL,Woocommerce Server URL
DocType: Item Reorder,Re-Order Level,Re-order Level
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Kupujte naslov poreza / dopuštenja
apps/erpnext/erpnext/projects/doctype/project/project.js +54,Gantt Chart,Gantogram
DocType: Crop Cycle,Cycle Type,Tip ciklusa
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +102,Part-time,Part - time
DocType: Employee,Applicable Holiday List,Primjenjivo odmor Popis
DocType: Employee,Cheque,Ček
DocType: Training Event,Employee Emails,Emails of Employee
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +67,Series Updated,Serija Updated
apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Report Type is mandatory,Vrsta izvjestaja je obavezna
DocType: Item,Serial Number Series,Serijski broj serije
apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Skladište je obvezno za skladišne proizvode {0} u redu {1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Trgovina na veliko i
DocType: Issue,First Responded On,Prvi put odgovorio dana
DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Oglas tačke u više grupa
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},Fiskalna godina Datum početka i datum završetka fiskalne godine već su postavljeni u fiskalnoj godini {0}
DocType: Projects Settings,Ignore User Time Overlap,Isključiti preklapanje korisničkog vremena
DocType: Accounting Period,Accounting Period,Period računovodstva
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113,Clearance Date updated,Razmak Datum ažurira
apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Split Batch
DocType: Stock Settings,Batch Identification,Identifikacija serije
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,Uspješno Pomirio
DocType: Request for Quotation Supplier,Download PDF,Preuzmi PDF
DocType: Work Order,Planned End Date,Planirani Završni datum
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Skrivena lista održavajući listu kontakata povezanih sa akcionarima
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,Tekući kurs
DocType: Item,"Sales, Purchase, Accounting Defaults","Prodaja, kupovina, podrazumevane vrednosti računovodstva"
apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informacije o donatoru.
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +192,{0} on Leave on {1},{0} na Pusti {1}
apps/erpnext/erpnext/assets/doctype/asset/asset.py +60,Available for use date is required,Potreban je datum upotrebe
DocType: Request for Quotation,Supplier Detail,dobavljač Detail
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +181,Error in formula or condition: {0},Greška u formuli ili stanja: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +112,Invoiced Amount,Fakturisanog
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Tegovi kriterijuma moraju dodati do 100%
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Pohađanje
apps/erpnext/erpnext/public/js/pos/pos.html +115,Stock Items,Stock Predmeti
DocType: Sales Invoice,Update Billed Amount in Sales Order,Ažurirajte naplaćeni iznos u prodajnom nalogu
DocType: BOM,Materials,Materijali
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Ako nije označeno, popis će biti dodan u svakom odjela gdje se mora primjenjivati."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +685,Posting date and posting time is mandatory,Datum knjiženja i knjiženje vrijeme je obvezna
apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Porezna Predložak za kupnju transakcije .
,Item Prices,Cijene artikala
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Klijent&gt; Grupa klijenata&gt; Teritorija
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,U riječi će biti vidljiv nakon što spremite narudžbenice.
DocType: Holiday List,Add to Holidays,Dodaj u praznike
DocType: Woocommerce Settings,Endpoint,Krajnja tačka
DocType: Period Closing Voucher,Period Closing Voucher,Razdoblje Zatvaranje bon
DocType: Patient Encounter,Review Details,Detalji pregleda
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +186,The shareholder does not belong to this company,Akcionar ne pripada ovoj kompaniji
DocType: Dosage Form,Dosage Form,Formular za doziranje
apps/erpnext/erpnext/config/selling.py +67,Price List master.,Cjenik majstor .
DocType: Task,Review Date,Datum pregleda
DocType: BOM,Allow Alternative Item,Dozvoli alternativu
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Serija za unos sredstava za amortizaciju (dnevnik)
DocType: Membership,Member Since,Član od
DocType: Purchase Invoice,Advance Payments,Avansna plaćanja
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1748,Please select Healthcare Service,Molimo odaberite Zdravstvenu službu
DocType: Purchase Taxes and Charges,On Net Total,Na Net Total
apps/erpnext/erpnext/controllers/item_variant.py +92,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Vrijednost za Atributi {0} mora biti u rasponu od {1} na {2} u koracima od {3} za Stavka {4}
DocType: Restaurant Reservation,Waitlisted,Waitlisted
DocType: Employee Tax Exemption Declaration Category,Exemption Category,Kategorija izuzeća
apps/erpnext/erpnext/accounts/doctype/account/account.py +131,Currency can not be changed after making entries using some other currency,Valuta ne mogu se mijenjati nakon što unose preko neke druge valute
DocType: Shipping Rule,Fixed,Fiksna
DocType: Vehicle Service,Clutch Plate,kvačila
DocType: Company,Round Off Account,Zaokružiti račun
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +100,Administrative Expenses,Administrativni troškovi
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,savjetodavni
DocType: Subscription Plan,Based on price list,Na osnovu cenovnika
DocType: Customer Group,Parent Customer Group,Roditelj Kupac Grupa
DocType: Vehicle Service,Change,Promjena
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +891,Subscription,Pretplata
DocType: Purchase Invoice,Contact Email,Kontakt email
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Čekanje stvaranja naknade
DocType: Appraisal Goal,Score Earned,Ocjena Zarađeni
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +222,Notice Period,Otkazni rok
DocType: Asset Category,Asset Category Name,Asset Ime kategorije
apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,To jekorijen teritorij i ne može se mijenjati .
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Ime prodaja novih lica
DocType: Packing Slip,Gross Weight UOM,Bruto težina UOM
DocType: Employee Transfer,Create New Employee Id,Kreirajte novi broj zaposlenih
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js +26,Set Details,Postavite detalje
DocType: Travel Itinerary,Travel From,Travel From
DocType: Asset Maintenance Task,Preventive Maintenance,Preventivno održavanje
DocType: Delivery Note Item,Against Sales Invoice,Protiv prodaje fakture
DocType: Purchase Invoice,07-Others,07-Ostalo
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +158,Please enter serial numbers for serialized item ,Unesite serijski brojevi za serijalizovanoj stavku
DocType: Bin,Reserved Qty for Production,Rezervirano Količina za proizvodnju
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Ostavite nekontrolisano ako ne želite uzeti u obzir batch prilikom donošenja grupe naravno na bazi.
DocType: Asset,Frequency of Depreciation (Months),Učestalost amortizacije (mjeseci)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +542,Credit Account,Kreditni račun
DocType: Landed Cost Item,Landed Cost Item,Sletio Troškovi artikla
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +58,Show zero values,Pokazati nulte vrijednosti
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina predmeta dobije nakon proizvodnju / pakiranje od navedenih količina sirovina
DocType: Lab Test,Test Group,Test grupa
DocType: Payment Reconciliation,Receivable / Payable Account,Potraživanja / Account plaćaju
DocType: Delivery Note Item,Against Sales Order Item,Protiv naloga prodaje Item
DocType: Company,Company Logo,Logo kompanije
apps/erpnext/erpnext/stock/doctype/item/item.py +767,Please specify Attribute Value for attribute {0},Molimo navedite vrijednost atributa za atribut {0}
DocType: Item Default,Default Warehouse,Glavno skladište
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +55,Budget cannot be assigned against Group Account {0},Budžet se ne može dodijeliti protiv grupe računa {0}
DocType: Shopping Cart Settings,Show Price,Prikaži cijene
DocType: Healthcare Settings,Patient Registration,Registracija pacijenata
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Please enter parent cost center,Unesite roditelj troška
DocType: Delivery Note,Print Without Amount,Ispis Bez visini
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +92,Depreciation Date,Amortizacija Datum
,Work Orders in Progress,Radni nalogi u toku
DocType: Issue,Support Team,Tim za podršku
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Isteka (u danima)
DocType: Appraisal,Total Score (Out of 5),Ukupna ocjena (od 5)
DocType: Student Attendance Tool,Batch,Serija
DocType: Support Search Source,Query Route String,String string upita
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1165,Update rate as per last purchase,Stopa ažuriranja po posljednjoj kupovini
DocType: Donor,Donor Type,Tip donatora
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +703,Auto repeat document updated,Automatsko ponavljanje dokumenta je ažurirano
apps/erpnext/erpnext/stock/doctype/item/item.js +29,Balance,Ravnoteža
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Izaberite kompaniju
DocType: Job Card,Job Card,Job Card
DocType: Room,Seating Capacity,Broj sjedećih mjesta
DocType: Issue,ISS-,ISS-
DocType: Lab Test Groups,Lab Test Groups,Laboratorijske grupe
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py +151,Party Type and Party is mandatory for {0} account,Party Party i Party je obavezan za {0} nalog
DocType: Project,Total Expense Claim (via Expense Claims),Ukupni rashodi potraživanja (preko rashodi potraživanja)
DocType: GST Settings,GST Summary,PDV Pregled
apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16,Please enable default incoming account before creating Daily Work Summary Group,Molimo vas da omogućite podrazumevani dolazni račun pre kreiranja Dnevnog pregleda rada
DocType: Assessment Result,Total Score,Ukupni rezultat
DocType: Crop Cycle,ISO 8601 standard,ISO 8601 standard
DocType: Journal Entry,Debit Note,Rashodi - napomena
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1513,You can only redeem max {0} points in this order.,Možete uneti samo max {0} poena u ovom redosledu.
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +102,Please enter API Consumer Secret,Molimo unesite API Potrošačku tajnu
DocType: Stock Entry,As per Stock UOM,Kao po burzi UOM
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Nije istekao
DocType: Student Log,Achievement,Postignuće
DocType: Asset,Insurer,Osiguravač
DocType: Batch,Source Document Type,Izvor Document Type
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Stvoreni su sledeći planovi kursa
DocType: Employee Onboarding,Employee Onboarding,Employee Onboarding
DocType: Journal Entry,Total Debit,Ukupno zaduženje
DocType: Travel Request Costing,Sponsored Amount,Sponzorirani iznos
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Uobičajeno Gotovi proizvodi skladište
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +316,Please select Patient,Molimo izaberite Pacijent
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Sales Person,Referent prodaje
DocType: Hotel Room Package,Amenities,Pogodnosti
apps/erpnext/erpnext/config/accounts.py +271,Budget and Cost Center,Budžet i troškova Center
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Višestruki način plaćanja nije dozvoljen
DocType: Sales Invoice,Loyalty Points Redemption,Povlačenje lojalnosti
,Appointment Analytics,Imenovanje analitike
DocType: Vehicle Service,Half Yearly,Polu godišnji
DocType: Lead,Blog Subscriber,Blog pretplatnik
DocType: Guardian,Alternate Number,Alternativna Broj
DocType: Assessment Plan Criteria,Maximum Score,Maksimalna Score
apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Stvaranje pravila za ograničavanje prometa na temelju vrijednosti .
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Mapiranje računa gotovine
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Grupa Roll Ne
DocType: Batch,Manufacturing Date,Datum proizvodnje
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Kreiranje Fee-a nije uspelo
DocType: Opening Invoice Creation Tool,Create Missing Party,Napravite Missing Party
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +85,Total Budget,Ukupni budžet
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Ostavite prazno ako napravite grupa studenata godišnje
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ako je označeno, Ukupan broj. radnih dana će uključiti odmor, a to će smanjiti vrijednost plaća po danu"
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +25,"Apps using current key won't be able to access, are you sure?","Aplikacije koje koriste trenutni ključ neće moći da pristupe, da li ste sigurni?"
DocType: Subscription Settings,Prorate,Prorate
DocType: Purchase Invoice,Total Advance,Ukupno predujma
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +78,Change Template Code,Promijenite šablon kod
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.,Termin Završni datum ne može biti ranije od termina Ozljede Datum. Molimo ispravite datume i pokušajte ponovo.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,quot Count
DocType: Bank Statement Transaction Entry,Bank Statement,Izjava banke
DocType: Employee Benefit Claim,Max Amount Eligible,Maksimalni iznos kvalifikovan
,BOM Stock Report,BOM Stock Report
DocType: Stock Reconciliation Item,Quantity Difference,Količina Razlika
DocType: Opportunity Item,Basic Rate,Osnovna stopa
DocType: GL Entry,Credit Amount,Iznos kredita
DocType: Cheque Print Template,Signatory Position,potpisnik Pozicija
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +184,Set as Lost,Postavi kao Lost
DocType: Timesheet,Total Billable Hours,Ukupno naplative Hours
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,Broj dana kada pretplatnik mora platiti fakture koje generiše ova pretplata
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,Detail Application Benefit Employee
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Plaćanje potvrda o primitku
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Ovo se zasniva na transakcije protiv ovog kupaca. Pogledajte vremenski okvir ispod za detalje
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Red {0}: Raspoređeni iznos {1} mora biti manji od ili jednak iznos plaćanja Entry {2}
DocType: Program Enrollment Tool,New Academic Term,Novi akademski termin
,Course wise Assessment Report,Naravno mudar Izvještaj o procjeni
DocType: Purchase Invoice,Availed ITC State/UT Tax,Iskoristio ITC državu / UT porez
DocType: Tax Rule,Tax Rule,Porez pravilo
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Održavati ista stopa Tijekom cijele prodajni ciklus
apps/erpnext/erpnext/hub_node/api.py +49,Please login as another user to register on Marketplace,Molimo prijavite se kao drugi korisnik da se registrujete na Marketplace
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planirajte vrijeme za rezanje izvan Workstation Radno vrijeme.
apps/erpnext/erpnext/public/js/pos/pos.html +98,Customers in Queue,Kupci u Queue
DocType: Driver,Issuing Date,Datum izdavanja
DocType: Procedure Prescription,Appointment Booked,Imenovanje rezervirano
DocType: Student,Nationality,državljanstvo
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +108,Submit this Work Order for further processing.,Pošaljite ovaj nalog za dalju obradu.
,Items To Be Requested,Potraživani artikli
DocType: Company,Company Info,Podaci o preduzeću
apps/erpnext/erpnext/accounts/page/pos/pos.js +1399,Select or add new customer,Odaberite ili dodati novi kupac
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +177,Cost center is required to book an expense claim,Troška je potrebno rezervirati trošak tvrdnju
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Primjena sredstava ( aktiva )
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,To se temelji na prisustvo ovog zaposlenih
DocType: Payment Request,Payment Request Type,Tip zahtjeva za plaćanje
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +113,Mark Attendance,Obeležite prisustvo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +536,Debit Account,Zaduži račun
DocType: Fiscal Year,Year Start Date,Početni datum u godini
DocType: Additional Salary,Employee Name,Ime i prezime radnika
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Restoran za unos stavke
DocType: Purchase Invoice,Rounded Total (Company Currency),Zaobljeni Ukupno (Društvo valuta)
apps/erpnext/erpnext/accounts/doctype/account/account.py +103,Cannot covert to Group because Account Type is selected.,"Ne mogu da konvertovanje Group, jer je izabran Account Type."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +270,{0} {1} has been modified. Please refresh.,{0} {1} je izmijenjen . Osvježite stranicu.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Prestani korisnike od izrade ostaviti aplikacija na sljedećim danima.
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +24,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.","Ako je neograničen rok isticanja za Loyalty Bodove, zadržite Trajanje isteka prazne ili 0."
DocType: Asset Maintenance Team,Maintenance Team Members,Članovi tima za održavanje
DocType: Loyalty Point Entry,Purchase Amount,Kupovina Iznos
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +251,"Cannot deliver Serial No {0} of item {1} as it is reserved \
											to fullfill Sales Order {2}",Ne može se dostaviti Serijski broj {0} stavke {1} pošto je rezervisan \ da biste ispunili nalog za prodaju {2}
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-YYYY-
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,Dobavljač Ponuda {0} stvorio
apps/erpnext/erpnext/accounts/report/financial_statements.py +104,End Year cannot be before Start Year,Kraja godine ne može biti prije početka godine
DocType: Employee Benefit Application,Employee Benefits,Primanja zaposlenih
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Packed quantity must equal quantity for Item {0} in row {1},Prepuna količina mora biti jednaka količina za točku {0} je u redu {1}
DocType: Work Order,Manufactured Qty,Proizvedeno Kol
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +79,The shares don't exist with the {0},Akcije ne postoje sa {0}
DocType: Sales Partner Type,Sales Partner Type,Vrsta prodajnog partnera
DocType: Shopify Webhook Detail,Webhook ID,Webhook ID
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Izrada fakture
DocType: Asset,Out of Order,Ne radi
DocType: Purchase Receipt Item,Accepted Quantity,Prihvaćena količina
DocType: Projects Settings,Ignore Workstation Time Overlap,Prezreti vremensko preklapanje radne stanice
apps/erpnext/erpnext/hr/doctype/employee/employee.py +259,Please set a default Holiday List for Employee {0} or Company {1},Molimo podesite default odmor Lista za zaposlenog {0} ili kompanije {1}
apps/erpnext/erpnext/accounts/party.py +30,{0}: {1} does not exists,{0}: {1} ne postoji
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +78,Select Batch Numbers,Izaberite šarže
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +231,To GSTIN,Za GSTIN
apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Mjenice podignuta na kupce.
DocType: Healthcare Settings,Invoice Appointments Automatically,Automatsko postavljanje fakture
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID Projekta
DocType: Salary Component,Variable Based On Taxable Salary,Varijabla zasnovana na oporezivoj plaći
DocType: Company,Basic Component,Osnovna komponenta
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +578,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},No red {0}: Iznos ne može biti veći od čekanju Iznos protiv rashodi potraživanje {1}. Na čekanju iznos je {2}
DocType: Patient Service Unit,Medical Administrator,Medicinski administrator
DocType: Assessment Plan,Schedule,Raspored
DocType: Account,Parent Account,Roditelj račun
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +297,Available,Dostupno
DocType: Quality Inspection Reading,Reading 3,Čitanje 3
DocType: Stock Entry,Source Warehouse Address,Adresa skladišta izvora
DocType: GL Entry,Voucher Type,Bon Tip
DocType: Amazon MWS Settings,Max Retry Limit,Maks retry limit
apps/erpnext/erpnext/accounts/page/pos/pos.js +1731,Price List not found or disabled,Cjenik nije pronađena ili invaliditetom
DocType: Student Applicant,Approved,Odobreno
apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,Cijena
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +349,Employee relieved on {0} must be set as 'Left',Zaposlenik razriješen na {0} mora biti postavljen kao 'lijevo '
DocType: Marketplace Settings,Last Sync On,Poslednja sinhronizacija uključena
DocType: Guardian,Guardian,staratelj
apps/erpnext/erpnext/support/doctype/issue/issue.js +48,All communications including and above this shall be moved into the new Issue,"Sve komunikacije, uključujući i iznad njih, biće premještene u novo izdanje"
DocType: Salary Detail,Tax on additional salary,Porez na dodatnu platu
DocType: Item Alternative,Item Alternative,Artikal Alternative
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,Uobičajeni računi prihoda koji će se koristiti ako nisu postavljeni u Zdravstvenom lekaru da rezervišu troškove naplate.
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Kreirajte nestalog klijenta ili dobavljača.
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Procjena {0} stvorena za zaposlenika {1} u određenom razdoblju
DocType: Academic Term,Education,Obrazovanje
DocType: Payroll Entry,Salary Slips Created,Izrada plata
DocType: Inpatient Record,Expected Discharge,Očekivano pražnjenje
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +594,Del,del
DocType: Selling Settings,Campaign Naming By,Imenovanje kampanja po
DocType: Employee,Current Address Is,Trenutni Adresa je
apps/erpnext/erpnext/utilities/user_progress.py +51,Monthly Sales Target (,Mesečna prodajna meta (
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modificirani
DocType: Travel Request,Identification Document Number,Identifikacioni broj dokumenta
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +41,"Optional. Sets company's default currency, if not specified.","Opcionalno. Postavlja kompanije Zadana valuta, ako nije navedeno."
DocType: Sales Invoice,Customer GSTIN,Customer 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 ,"Spisak otkrivenih bolesti na terenu. Kada je izabran, automatski će dodati listu zadataka koji će se baviti bolesti"
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js +30,This is a root healthcare service unit and cannot be edited.,Ovo je koren zdravstvenog servisa i ne može se uređivati.
DocType: Asset Repair,Repair Status,Status popravke
apps/erpnext/erpnext/public/js/event.js +31,Add Sales Partners,Dodajte partnera za prodaju
apps/erpnext/erpnext/config/accounts.py +84,Accounting journal entries.,Računovodstvene stavke
DocType: Travel Request,Travel Request,Zahtjev za putovanje
DocType: Delivery Note Item,Available Qty at From Warehouse,Dostupno Količina na Od Skladište
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py +17,Please select Employee Record first.,Molimo odaberite zaposlenih Record prvi.
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +52,Attendance not submitted for {0} as it is a Holiday.,Prisustvo nije poslato za {0} jer je to praznik.
DocType: POS Profile,Account for Change Amount,Nalog za promjene Iznos
DocType: Exchange Rate Revaluation,Total Gain/Loss,Ukupni dobitak / gubitak
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1168,Invalid Company for Inter Company Invoice.,Nevažeća kompanija za račun kompanije.
DocType: Purchase Invoice,input service,ulazna usluga
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +249,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Red {0}: Party / računa ne odgovara {1} / {2} u {3} {4}
DocType: Employee Promotion,Employee Promotion,Promocija zaposlenih
DocType: Maintenance Team Member,Maintenance Team Member,Član tima za održavanje
DocType: Agriculture Analysis Criteria,Soil Analysis,Analiza tla
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Course Code: ,Šifra predmeta:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,Please enter Expense Account,Unesite trošak računa
DocType: Account,Stock,Zaliha
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1128,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Referenca Vrsta dokumenta mora biti jedan od Narudžbenice, fakturi ili Journal Entry"
DocType: Employee,Current Address,Trenutna adresa
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","Ako proizvod varijanta druge stavke onda opis, slike, cijene, poreze itd će biti postavljena iz predloška, osim ako izričito navedeno"
DocType: Serial No,Purchase / Manufacture Details,Kupnja / Proizvodnja Detalji
DocType: Assessment Group,Assessment Group,procjena Group
apps/erpnext/erpnext/config/stock.py +332,Batch Inventory,Batch zaliha
DocType: Supplier,GST Transporter ID,ID transportera GST
DocType: Procedure Prescription,Procedure Name,Ime postupka
DocType: Employee,Contract End Date,Ugovor Datum završetka
DocType: Amazon MWS Settings,Seller ID,ID prodavca
DocType: Sales Order,Track this Sales Order against any Project,Prati ovu porudzbinu na svim Projektima
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,Prijavljivanje transakcije u banci
DocType: Sales Invoice Item,Discount and Margin,Popust i Margin
DocType: Lab Test,Prescription,Prescription
DocType: Company,Default Deferred Revenue Account,Podrazumevani odloženi porezni račun
DocType: Project,Second Email,Druga e-pošta
DocType: Budget,Action if Annual Budget Exceeded on Actual,Akcija ako se godišnji budžet premašuje na aktuelnom nivou
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +127,Not Available,nije dostupno
DocType: Pricing Rule,Min Qty,Min kol
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +41,Disable Template,Onemogući šablon
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +105,Please select Healthcare Practitioner and Date,Molimo odaberite Zdravstvenu praksu i datum
DocType: Bank Statement Transaction Invoice Item,Transaction Date,Transakcija Datum
DocType: Production Plan Item,Planned Qty,Planirani Kol
DocType: Company,Date of Incorporation,Datum osnivanja
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Ukupno porez
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +40,Last Purchase Price,Poslednja cena otkupa
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +280,For Quantity (Manufactured Qty) is mandatory,Za Količina (Proizvedeno Qty) je obavezno
DocType: Stock Entry,Default Target Warehouse,Centralno skladište
DocType: Purchase Invoice,Net Total (Company Currency),Neto Ukupno (Društvo valuta)
DocType: Delivery Note,Air,Zrak
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.,The Year Završni datum ne može biti ranije od godine Ozljede Datum. Molimo ispravite datume i pokušajte ponovo.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +278,{0} is not in Optional Holiday List,{0} nije u opcionoj popisnoj listi
DocType: Notification Control,Purchase Receipt Message,Poruka primke
DocType: Amazon MWS Settings,JP,JP
DocType: BOM,Scrap Items,Scrap Predmeti
DocType: Job Card,Actual Start Date,Stvarni datum početka
DocType: Sales Order,% of materials delivered against this Sales Order,% Materijala dostavljenih od ovog prodajnog naloga
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Work Orders.,Generiranje zahteva za materijal (MRP) i radnih naloga.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Podesi podrazumevani način plaćanja
DocType: Grant Application,Withdrawn,povučen
DocType: Support Search Source,Support Search Source,Podrška za pretragu
DocType: Project,Gross Margin %,Bruto marža %
DocType: BOM,With Operations,Uz operacije
DocType: Support Search Source,Post Route Key List,Lista spiska ključeva
apps/erpnext/erpnext/accounts/party.py +288,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Računovodstvo stavke su već učinjeni u valuti {0} {1} za firmu. Molimo odaberite potraživanja ili platiti račun s valutnom {0}.
DocType: Asset,Is Existing Asset,Je Postojeći imovine
DocType: Salary Component,Statistical Component,statistička komponenta
DocType: Warranty Claim,If different than customer address,Ako se razlikuje od kupaca adresu
DocType: Purchase Invoice,Without Payment of Tax,Bez plaćanja poreza
DocType: BOM Operation,BOM Operation,BOM operacija
apps/erpnext/erpnext/config/stock.py +144,Fulfilment,Ispunjavanje
DocType: Purchase Taxes and Charges,On Previous Row Amount,Na prethodnu Row visini
DocType: Item,Has Expiry Date,Ima datum isteka
apps/erpnext/erpnext/assets/doctype/asset/asset.js +367,Transfer Asset,Transfer imovine
DocType: POS Profile,POS Profile,POS profil
DocType: Training Event,Event Name,Naziv događaja
DocType: Healthcare Practitioner,Phone (Office),Telefon (Office)
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +21,"Cannot Submit, Employees left to mark attendance","Ne mogu da pošaljem, Zaposleni su ostavljeni da obilježavaju prisustvo"
DocType: Inpatient Record,Admission,upis
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Priznanja za {0}
apps/erpnext/erpnext/config/accounts.py +295,"Seasonality for setting budgets, targets etc.","Sezonski za postavljanje budžeta, ciljeva itd"
DocType: Supplier Scorecard Scoring Variable,Variable Name,Ime promenljive
apps/erpnext/erpnext/stock/get_item_details.py +163,"Item {0} is a template, please select one of its variants","Stavka {0} je predložak, odaberite jednu od njegovih varijanti"
DocType: Purchase Invoice Item,Deferred Expense,Odloženi troškovi
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +26,From Date {0} cannot be before employee's joining Date {1},Od datuma {0} ne može biti pre pridruživanja zaposlenog Datum {1}
DocType: Asset,Asset Category,Asset Kategorija
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,Net pay cannot be negative,Neto plaća ne može biti negativna
DocType: Purchase Order,Advance Paid,Advance Paid
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Procenat prekomerne proizvodnje za porudžbinu prodaje
DocType: Item,Item Tax,Porez artikla
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +943,Material to Supplier,Materijal dobavljaču
DocType: Soil Texture,Loamy Sand,Loamy Sand
DocType: Production Plan,Material Request Planning,Planiranje zahtjeva za materijal
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +700,Excise Invoice,Akcizama Račun
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Prag {0}% se pojavljuje više od jednom
DocType: Expense Claim,Employees Email Id,Zaposlenici Email ID
DocType: Employee Attendance Tool,Marked Attendance,Označena Posjeta
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Current Liabilities,Kratkoročne obveze
apps/erpnext/erpnext/public/js/projects/timer.js +138,Timer exceeded the given hours.,Tajmer je prekoračio zadate sate.
apps/erpnext/erpnext/config/selling.py +303,Send mass SMS to your contacts,Pošalji masovne SMS poruke svojim kontaktima
DocType: Inpatient Record,A Positive,Pozitivan
DocType: Program,Program Name,Naziv programa
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Razmislite poreza ili pristojbi za
DocType: Driver,Driving License Category,Kategorija vozačke dozvole
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Stvarni Qty je obavezno
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +89,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} trenutno ima {1} Scorecard stava, a narudžbine za ovaj dobavljač treba izdati oprezno."
DocType: Asset Maintenance Team,Asset Maintenance Team,Tim za održavanje imovine
apps/erpnext/erpnext/setup/default_success_action.py +13,{0} has been submitted successfully,{0} je uspešno podnet
DocType: Loan,Loan Type,Vrsta kredita
DocType: Scheduling Tool,Scheduling Tool,zakazivanje alata
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +156,Credit Card,kreditna kartica
DocType: BOM,Item to be manufactured or repacked,Artikal će biti proizveden ili prepakiran
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +766,Syntax error in condition: {0},Sintaksna greška u stanju: {0}
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
DocType: Employee Education,Major/Optional Subjects,Glavni / Izborni predmeti
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +121,Please Set Supplier Group in Buying Settings.,Molim postavite grupu dobavljača u Podešavanja kupovine.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,"Total flexible benefit component amount {0} should not be less \
				than max benefits {1}",Ukupna količina fleksibilne komponente koristi {0} ne bi trebalo da bude manje od maksimalnih koristi {1}
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Driver,Suspended,Suspendirano
DocType: Training Event,Attendees,Polaznici
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Ovdje možete održavati obiteljske pojedinosti kao što su ime i okupacije roditelja, supružnika i djecu"
DocType: Academic Term,Term End Date,Term Završni datum
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Porezi i naknade Umanjenja (Društvo valuta)
DocType: Item Group,General Settings,General Settings
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Od valute i valuta ne mogu biti isti
DocType: Taxable Salary Slab,Percent Deduction,Procenat odbijanja
DocType: Stock Entry,Repack,Prepakovati
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Morate spremiti obrazac prije nastavka
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +125,Please select the Company first,Molimo prvo odaberite Kompaniju
DocType: Item Attribute,Numeric Values,Brojčane vrijednosti
apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Priložiti logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,Stock Nivoi
DocType: Customer,Commission Rate,Komisija Stopa
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py +240,Successfully created payment entries,Uspješno su kreirani unosi plaćanja
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Napravljene {0} pokazivačke karte za {1} između:
apps/erpnext/erpnext/stock/doctype/item/item.js +584,Make Variant,Make Variant
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +156,"Payment Type must be one of Receive, Pay and Internal Transfer","Plaćanje Tip mora biti jedan od Primi, Pay i unutrašnje Transfer"
DocType: Travel Itinerary,Preferred Area for Lodging,Preferirana oblast za smeštaj
apps/erpnext/erpnext/config/selling.py +184,Analytics,analitika
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Košarica je prazna
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +416,"Item {0} has no Serial No. Only serilialized items \
						can have delivery based on Serial No",Stavka {0} nema serijski broj. Samo serijalizirani predmeti \ mogu imati isporuku zasnovanu na Serijski broj
DocType: Vehicle,Model,model
DocType: Work Order,Actual Operating Cost,Stvarni operativnih troškova
DocType: Payment Entry,Cheque/Reference No,Ček / Reference Ne
DocType: Soil Texture,Clay Loam,Clay Loam
apps/erpnext/erpnext/accounts/doctype/account/account.py +88,Root cannot be edited.,Korijen ne može se mijenjati .
DocType: Item,Units of Measure,Jedinice mjere
DocType: Employee Tax Exemption Declaration,Rented in Metro City,Iznajmljen u gradu Metro
DocType: Supplier,Default Tax Withholding Config,Podrazumevana poreska obaveza zadržavanja poreza
DocType: Manufacturing Settings,Allow Production on Holidays,Dopustite Production o praznicima
DocType: Sales Invoice,Customer's Purchase Order Date,Kupca narudžbenice Datum
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +173,Capital Stock,Kapitala
DocType: Asset,Default Finance Book,Osnovna finansijska knjiga
DocType: Shopping Cart Settings,Show Public Attachments,Pokaži Javna Prilozi
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js +3,Edit Publishing Details,Izmenite podatke o objavljivanju
DocType: Packing Slip,Package Weight Details,Težina paketa - detalji
DocType: Leave Type,Is Compensatory,Is Kompenzacija
DocType: Restaurant Reservation,Reservation Time,Vrijeme rezervacije
DocType: Payment Gateway Account,Payment Gateway Account,Payment Gateway računa
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Nakon završetka uplate preusmjeriti korisnika na odabrani stranicu.
DocType: Company,Existing Company,postojeći Company
DocType: Healthcare Settings,Result Emailed,Rezultat poslat
apps/erpnext/erpnext/controllers/buying_controller.py +99,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Porez Kategorija je promijenjen u &quot;Total&quot;, jer svi proizvodi bez stanju proizvodi"
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +35,To date can not be equal or less than from date,Do danas ne može biti jednaka ili manja od datuma
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +118,Nothing to change,Ništa se ne menja
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +104,Please select a csv file,Odaberite CSV datoteku
DocType: Holiday List,Total Holidays,Total Holidays
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +109,Missing email template for dispatch. Please set one in Delivery Settings.,Nedostajući e-mail predložak za otpremu. Molimo vas da podesite jednu od postavki isporuke.
DocType: Student Leave Application,Mark as Present,Mark kao Present
DocType: Supplier Scorecard,Indicator Color,Boja boje
DocType: Purchase Order,To Receive and Bill,Da primi i Bill
apps/erpnext/erpnext/controllers/buying_controller.py +679,Row #{0}: Reqd by Date cannot be before Transaction Date,Red # {0}: Reqd po datumu ne može biti pre datuma transakcije
apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Istaknuti Proizvodi
apps/erpnext/erpnext/assets/doctype/asset/asset.js +384,Select Serial No,Izaberite serijski broj
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Designer,Imenovatelj
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Uvjeti predloška
DocType: Serial No,Delivery Details,Detalji isporuke
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +612,Cost Center is required in row {0} in Taxes table for type {1},Troška potrebno je u redu {0} poreza stolom za vrstu {1}
DocType: Program,Program Code,programski kod
DocType: Terms and Conditions,Terms and Conditions Help,Uslovi Pomoć
,Item-wise Purchase Register,Stavka-mudar Kupnja Registracija
DocType: Loyalty Point Entry,Expiry Date,Datum isteka
DocType: Healthcare Settings,Employee name and designation in print,Ime i oznaka zaposlenika u štampi
,accounts-browser,računi pretraživač
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +381,Please select Category first,Molimo odaberite kategoriju prvi
apps/erpnext/erpnext/config/projects.py +13,Project master.,Direktor Projekata
apps/erpnext/erpnext/controllers/status_updater.py +215,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Da biste omogućili nad-naplate ili preko-naručivanje, ažurirati &quot;Ispravka&quot; raspoloživo Settings ili stavku."
DocType: Contract,Contract Terms,Uslovi ugovora
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Ne pokazati nikakav simbol poput $ iza valute.
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +89,Maximum benefit amount of component {0} exceeds {1},Maksimalna visina komponente komponente {0} prelazi {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +529, (Half Day),(Pola dana)
DocType: Payment Term,Credit Days,Kreditne Dani
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +140,Please select Patient to get Lab Tests,Izaberite Pacijent da biste dobili laboratorijske testove
apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Make Student Batch
DocType: BOM Explosion Item,Allow Transfer for Manufacture,Dozvolite prenos za proizvodnju
DocType: Leave Type,Is Carry Forward,Je Carry Naprijed
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +984,Get Items from BOM,Kreiraj proizvode od sastavnica (BOM)
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Potencijalni kupac - ukupno dana
DocType: Cash Flow Mapping,Is Income Tax Expense,Da li je porez na prihod?
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py +19,Your order is out for delivery!,Vaša narudžba je isporučena!
apps/erpnext/erpnext/controllers/accounts_controller.py +677,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Slanje poruka Datum mora biti isti kao i datum kupovine {1} od imovine {2}
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Označite ovu ako student boravi na Instituta Hostel.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Molimo unesite Prodajni nalozi u gornjoj tablici
,Stock Summary,Stock Pregled
apps/erpnext/erpnext/config/assets.py +62,Transfer an asset from one warehouse to another,Transfer imovine iz jednog skladišta u drugo
DocType: Vehicle,Petrol,benzin
DocType: Employee Benefit Application,Remaining Benefits (Yearly),Preostale koristi (godišnje)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +865,Bill of Materials,Bill of Materials
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +137,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Red {0}: Party Tip i stranka je potreban za potraživanja / računa plaćaju {1}
DocType: Employee,Leave Policy,Leave Policy
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +858,Update Items,Ažurirati stavke
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref: Datum
DocType: Employee,Reason for Leaving,Razlog za odlazak
DocType: BOM Operation,Operating Cost(Company Currency),Operativni trošak (Company Valuta)
DocType: Loan Application,Rate of Interest,Kamatna stopa
DocType: Expense Claim Detail,Sanctioned Amount,Iznos kažnjeni
DocType: Item,Shelf Life In Days,Rok trajanja u danima
DocType: GL Entry,Is Opening,Je Otvaranje
DocType: Department,Expense Approvers,Izdaci za troškove
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +228,Row {0}: Debit entry can not be linked with a {1},Row {0}: Debitne stavka ne može se povezati sa {1}
DocType: Journal Entry,Subscription Section,Subscription Section
apps/erpnext/erpnext/accounts/doctype/account/account.py +238,Account {0} does not exist,Konto {0} ne postoji
DocType: Training Event,Training Program,Program obuke
DocType: Account,Cash,Gotovina
DocType: Employee,Short biography for website and other publications.,Kratka biografija za web stranice i druge publikacije.
