apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening','Početno stanje'
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Prosjek dnevne isporuke
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Kreirajte uplatu
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Uvoz nije uspio!
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti obrisano dok postoji zaliha za artikal {1}
DocType: Item,Is Purchase Item,Artikal je za poručivanje
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Skladište {0} ne postoji
apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Potvrđene porudžbine od strane kupaca
apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Klinika (beta)
DocType: Salary Slip,Salary Structure,Структура плата
DocType: Item Reorder,Item Reorder,Dopuna artikla
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Prijavi grešku
DocType: Salary Slip,Net Pay,Neto plaćanje
DocType: Purchase Invoice Item,Item Tax Rate,Poreska stopa
apps/erpnext/erpnext/accounts/page/pos/pos.js +1524,Create a new Customer,Kreirajte novog kupca
DocType: Item Variant Attribute,Attribute,Atribut
DocType: POS Profile,POS Profile,POS profil
DocType: Pricing Rule,Min Qty,Min količina
DocType: Purchase Invoice,Currency and Price List,Valuta i cjenovnik
DocType: POS Profile,Write Off Account,Otpisati nalog
DocType: Stock Entry,Delivery Note No,Broj otpremnice
DocType: Item,Serial Nos and Batches,Serijski brojevi i paketi
DocType: Activity Cost,Projects User,Projektni korisnik
DocType: Lead,Address Desc,Opis adrese
DocType: Mode of Payment,Mode of Payment,Način plaćanja
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Moja korpa
DocType: Bank Guarantee,End Date,Datum završetka
DocType: Consultation,Doctor,Doktor
DocType: Payment Entry,Payment From / To,Plaćanje od / za
DocType: Purchase Invoice,Grand Total (Company Currency),Za plaćanje (Valuta preduzeća)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +258,Insufficient Stock,Nedovoljna količina
DocType: Purchase Invoice,Shipping Rule,Pravila nabavke
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Bruto dobit / gubitak
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Pritisnite na artikal da bi ga dodali ovdje
,Sales Order Trends,Trendovi prodajnih naloga
DocType: Sales Invoice,Offline POS Name,POS naziv  u režimu van mreže (offline)
DocType: Request for Quotation Item,Project Name,Naziv Projekta
DocType: Company,Last Day of the Next Month,Posljednji dan u narednom mjesecu
DocType: Item,Material Transfer,Prenos robe
DocType: Bank Guarantee,Project,Projekti
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +496,Change POS Profile,Promijenite POS korisnika
apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Napravi predračun
DocType: Bank Guarantee,Customer,Kupac
DocType: Purchase Order Item,Supplier Quotation Item,Stavka na dobavljačevoj ponudi
DocType: Item Group,General Settings,Opšta podešavanja
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Staros bazirana na
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Poručeno
apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,Gram
DocType: Journal Entry Account,Purchase Invoice,Faktura nabavke
DocType: Period Closing Voucher,Closing Fiscal Year,Zatvaranje fiskalne godine
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Grupiši po knjiženjima
DocType: Item,Customer Code,Šifra kupca
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Dozvolite više prodajnih naloga koji su vezani sa porudžbenicom kupca
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Ukupno isporučeno
DocType: Consultation,Consultation Time,Vrijeme pregleda
,Sales Register,Pregled Prodaje
DocType: Sales Order,%  Delivered,% Isporučeno
DocType: Journal Entry Account,Party Balance,Stanje kupca
apps/erpnext/erpnext/config/selling.py +23,Customers,Kupci
DocType: Project,Task Completion,Završenost zadataka
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Set as Lost,Obilježi kao izgubljenu
DocType: Production Order,Production Order,Proizvodne porudžbine
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Kupovina
apps/erpnext/erpnext/accounts/party.py +384,{0} {1} is not active,{0} {1} nije aktivan
DocType: Bin,Reserved Quantity,Rezervisana količina
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +809,Return / Credit Note,Povraćaj / knjižno odobrenje
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,Get Items from BOM,Dodaj stavke iz  БОМ
apps/erpnext/erpnext/accounts/page/pos/pos.js +2021,Please select customer,Odaberite kupca
apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Nova adresa
,Stock Summary,Pregled zalihe
DocType: Purchase Invoice Item,Net Rate (Company Currency),Neto cijena sa rabatom (Valuta preduzeća)
DocType: Stock Entry Detail,Additional Cost,Dodatni trošak
,Purchase Invoice Trends,Trendovi faktura dobavljaća
DocType: Item Price,Item Price,Cijena artikla
DocType: Sales Order Item,Sales Order Date,Datum prodajnog naloga
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Otpremnica {0} se ne može potvrditi
apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} status je {2}
DocType: BOM,Item Image (if not slideshow),Slika artikla (ako nije prezentacija)
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Pregledi
DocType: Territory,Classification of Customers by region,Klasifikacija kupaca po regiji
DocType: Quotation,Quotation To,Ponuda za
apps/erpnext/erpnext/config/projects.py +41,Timesheet for tasks.,Potrošeno vrijeme za zadatke
DocType: Journal Entry,Remark,Napomena
apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Korisnik {0} je već dodijeljen ljekaru {1}
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Stablo Vrste artikala
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Grupa kupaca / kupci
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Pregled potraživanja od kupaca
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Iz otpremnice
DocType: Account,Tax,Porez
DocType: Bank Reconciliation,Account Currency,Valuta računa
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Otvoreni projekti
DocType: POS Profile,Price List,Cjenovnik
DocType: Purchase Invoice Item,Rate (Company Currency),Cijena sa rabatom (Valuta preduzeća)
DocType: Activity Cost,Projects,Projekti
DocType: Purchase Invoice,Supplier Name,Naziv dobavljača
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +193,Closing (Opening + Total),Ukupno (P.S + promet u periodu)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,Supplier Invoice Date cannot be greater than Posting Date,Datum fakture dobavljača ne može biti veći od datuma otvaranja fakture
DocType: Production Planning Tool,Sales Orders,Prodajni nalozi
DocType: Item,Manufacturer Part Number,Proizvođačka šifra
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Prosječna vrijednost nabavke
DocType: Sales Order Item,Gross Profit,Bruto dobit
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Grupiši po računu.
DocType: Opening Invoice Creation Tool Item,Item Name,Naziv artikla
DocType: Item,Will also apply for variants,Biće primijenjena i na varijante
DocType: Purchase Invoice,Total Advance,Ukupno Avans
apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Prodajni nalog za plaćanje
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,Serijski broj {0} ne pripada ni jednom skladištu
,Sales Analytics,Prodajna analitika
DocType: Patient Appointment,Patient Age,Starost pacijenta
DocType: Sales Invoice,Customer Address,Adresa kupca
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Ukupno bez PDV-a (duguje)
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,Slovima (izvoz) će biti vidljiv onda kad sačuvate otpremnicu
DocType: Opportunity,Opportunity Date,Datum prilike
DocType: Sales Invoice Item,Delivery Note Item,Pozicija otpremnice
DocType: Sales Order,Customer's Purchase Order,Porudžbenica kupca
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Dodaj stavke iz
DocType: C-Form,Total Invoiced Amount,Ukupno fakturisano
DocType: Purchase Invoice,Supplier Invoice Date,Datum fakture dobavljača
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +158,Journal Entry {0} does not have account {1} or already matched against other voucher,Knjiženje {0} nema nalog {1} ili je već povezan sa drugim izvodom
DocType: Lab Test,Lab Test,Lab test
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +29,-Above,- Iznad
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +209,{0} {1} is cancelled or stopped,{0} {1} je otkazan ili stopiran
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Porezi i naknade dodate (valuta preduzeća)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Bilješka: {0}
DocType: Lead,Lost Quotation,Izgubljen Predračun
DocType: Account,Account,Račun
apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Računovodstvo: {0} može samo da se ažurira u dijelu Promjene na zalihama
DocType: Employee Leave Approver,Leave Approver,Odobrava izlaske s posla
DocType: Authorization Rule,Customer or Item,Kupac ili proizvod
,Requested Qty,Tražena kol
apps/erpnext/erpnext/stock/get_item_details.py +129,No Item with Serial No {0},Ne postoji artikal sa serijskim brojem {0}
DocType: POS Profile,Taxes and Charges,Porezi i naknade
DocType: Item,Serial Number Series,Serijski broj serije
DocType: Purchase Order,Delivered,Isporučeno
DocType: Selling Settings,Default Territory,Podrazumijevana država
DocType: Asset,Asset Category,Grupe osnovnih sredstava
DocType: Sales Invoice Item,Customer Warehouse (Optional),Skladište kupca (opciono)
DocType: Delivery Note Item,From Warehouse,Iz skladišta
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Prikaži zatvorene
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Physician not available on {0},Ljekar nije dostupan u {0}
DocType: Customer,Additional information regarding the customer.,Dodatne informacije o kupcu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +449,Warehouse required for stock Item {0},Skladište je potrebno unijeti za artikal {0}
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,Uplata već postoji
DocType: Project,Customer Details,Korisnički detalji
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 ##### 
 Ако Радња је смештена i serijski broj se ne pominje u transakcijama, onda će automatski serijski broj biti kreiran na osnovu ove serije. Ukoliko uvijek želite da eksplicitno spomenete serijski broj ove šifre, onda je ostavite praznu."
apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Kupac i dobavljač
DocType: Project,% Completed,% završen
DocType: Journal Entry Account,Sales Invoice,Faktura prodaje
DocType: Journal Entry,Accounting Entries,Računovodstveni unosi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Red # {0}: Knjiženje {1} nema kreiran nalog {2} ili je već povezan sa drugim izvodom.
DocType: Purchase Invoice,Print Language,Jezik za štampu
DocType: Antibiotic,Healthcare Administrator,Administrator klinike
DocType: Sales Order,Track this Sales Order against any Project,Prati ovaj prodajni nalog na bilo kom projektu
DocType: Quotation Item,Stock Balance,Pregled trenutne zalihe
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +515,[Error],[Greška]
DocType: Supplier,Supplier Details,Detalji o dobavljaču
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum zajednice
,Batch Item Expiry Status,Pregled artikala sa rokom trajanja
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Payment,Plaćanje
,Sales Partners Commission,Provizija za prodajne partnere
DocType: C-Form Invoice Detail,Territory,Teritorija
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Cjenovnik {0} je zaključan
DocType: Notification Control,Sales Order Message,Poruka prodajnog naloga
DocType: Email Digest,Pending Sales Orders,Prodajni nalozi na čekanju
apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minut
apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Litar
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +225,Opening (Cr),Početno stanje (Po)
DocType: Academic Term,Academics User,Akademski korisnik
DocType: Student,Blood Group,Krvna grupa
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Izjava o računu
DocType: Delivery Note,Billing Address,Adresa za naplatu
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,Sve države
DocType: Payment Entry,Received Amount (Company Currency),Iznos uplate (Valuta preduzeća)
DocType: Bin,Ordered Quantity,Poručena količina
DocType: Lab Test Template,Standard Selling Rate,Standarna prodajna cijena
apps/erpnext/erpnext/config/setup.py +122,Human Resources,Ljudski resursi
DocType: Sales Invoice Item,Rate With Margin,Cijena sa popustom
apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Dodaj potrošeno vrijeme
DocType: Healthcare Settings,Consultations in valid days,Pregledi u važećim danima
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Korisnički portal
DocType: Purchase Order Item Supplied,Stock UOM,JM zalihe
DocType: Fee Validity,Valid Till,Važi do
apps/erpnext/erpnext/accounts/page/pos/pos.js +1375,Select or add new customer,Izaberite ili dodajte novog kupca
,Trial Balance for Party,Struktura dugovanja
DocType: Program Enrollment Tool,New Program,Novi program
DocType: Product Bundle Item,Product Bundle Item,Sastavljeni proizvodi
DocType: Lead,Address & Contact,Adresa i kontakt
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Make ,Napravi
DocType: Bin,Reserved Qty for Production,Rezervisana kol. za proizvodnju
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Ovo praćenje je zasnovano na kretanje zaliha. Pogledajte {0} za više detalja
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Svi kontakti
DocType: Consultation,Consultation Date,Datum pregleda
DocType: Item,Default Warehouse,Podrazumijevano skladište
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Тренутно не постоје залихе у складишту
DocType: Company,Default Letter Head,Podrazumijevano zaglavlje
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Prodajni nalog {0} nije validan
DocType: Account,Credit,Potražuje
DocType: C-Form Invoice Detail,Grand Total,Za plaćanje
apps/erpnext/erpnext/config/learn.py +234,Human Resource,Ljudski resursi
DocType: Selling Settings,Delivery Note Required,Otpremnica je obavezna
DocType: Payment Entry,Type of Payment,Vrsta plaćanja
DocType: Purchase Invoice Item,UOM,JM
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +59,Difference Amount must be zero,Razlika u iznosu mora biti nula
DocType: Sales Order,Not Delivered,Nije isporučeno
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Prodajne kampanje
DocType: Item,Auto re-order,Automatska porudžbina
,Profit and Loss Statement,Bilans uspjeha
apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,Metar
apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Par
,Profitability Analysis,Analiza profitabilnosti
DocType: Attendance,HR Manager,Menadžer za ljudske resurse
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Porez (valuta preduzeća)
DocType: Asset,Quality Manager,Menadžer za kvalitet
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,Faktura prodaje {0} je već potvrđena
DocType: Project Task,Weight,Težina
DocType: Sales Invoice Timesheet,Timesheet Detail,Detalji potrošenog vremena
DocType: Purchase Invoice,Is Return,Da li je povratak
DocType: Stock Entry,Material Receipt,Prijem robe
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673,Supplier Invoice No exists in Purchase Invoice {0},Broj fakture dobavljača već postoji u fakturi nabavke {0}
DocType: Asset Movement,Source Warehouse,Izvorno skladište
apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Upravljanje projektima
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Kalkulacija
DocType: Supplier,Name and Type,Ime i tip
DocType: Customs Tariff Number,Customs Tariff Number,Carinska tarifa
DocType: Item,Default Supplier,Podrazumijevani dobavljač
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Izaberite pacijenta
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +191,Opening,Početno stanje
DocType: POS Profile,Customer Groups,Grupe kupaca
DocType: Brand,Item Manager,Menadžer artikala
DocType: Fiscal Year Company,Fiscal Year Company,Fiskalna godina preduzeća
DocType: Patient Appointment,Patient Appointment,Zakazivanje pacijenata
DocType: Company,Credit Days Based On,Dani dugovanja bazirani na
DocType: BOM,Show In Website,Prikaži na web sajtu
DocType: Payment Entry,Paid Amount,Uplaćeno
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23,Total Paid Amount,Ukupno plaćeno
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,Prijem robe {0} nije potvrđen
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Proizvodi i cijene
DocType: Payment Entry,Account Paid From,Račun plaćen preko
apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Kreirajte bilješke kupca
DocType: Purchase Invoice,Supplier Warehouse,Skladište dobavljača
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Kupac je obavezan podatak
DocType: Item,Customer Item Codes,Šifra kod kupca
DocType: Item,Manufacturer,Proizvođač
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Selling Amount,Prodajni iznos
DocType: Item,Allow over delivery or receipt upto this percent,Dozvolite isporukuili prijem robe ukoliko ne premaši ovaj procenat
DocType: Shopping Cart Settings,Orders,Porudžbine
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Promjene na zalihama
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +968,Add items from,Dodaj stavke iz
,Daily Timesheet Summary,Pregled dnevnog potrošenog vremena
DocType: Project Task,View Timesheet,Pogledaj potrošeno vrijeme
DocType: Purchase Invoice,Rounded Total (Company Currency),Zaokruženi ukupan iznos (valuta preduzeća)
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ako ovaj artikal ima varijante, onda ne može biti biran u prodajnom nalogu."
DocType: Pricing Rule,Discount on Price List Rate (%),Popust na cijene iz cjenovnika (%)
DocType: Item,Item Attribute,Atribut artikla
DocType: Payment Request,Amount in customer's currency,Iznos u valuti kupca
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Skladište je obavezan podatak
,Stock Ageing,Starost zaliha
DocType: Email Digest,New Sales Orders,Novi prodajni nalozi
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +21,Cart is Empty,Korpa je prazna
DocType: Patient,Patient Details,Detalji o pacijentu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +537,Stock Entry {0} is not submitted,Unos zaliha {0} nije potvrđen
apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Ostatak svijeta
DocType: Production Order,Additional Operating Cost,Dodatni operativni troškovi
DocType: Purchase Invoice,Rejected Warehouse,Odbijeno skladište
DocType: Asset Repair,Manufacturing Manager,Menadžer proizvodnje
DocType: Shopping Cart Settings,Enable Shopping Cart,Omogući korpu
DocType: Purchase Invoice Item,Is Fixed Asset,Artikal je osnovno sredstvo
,POS,POS
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +284,Timesheet {0} is already completed or cancelled,Potrošeno vrijeme {0} je već potvrđeno ili otkazano
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +491, (Half Day),(Pola dana)
DocType: Shipping Rule,Net Weight,Neto težina
DocType: Payment Entry Reference,Outstanding,Preostalo
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Popust (%)
DocType: Purchase Invoice,Select Shipping Address,Odaberite adresu isporuke
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Iznos za fakturisanje
apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Kreiranje prodajnog naloga će vam pomoći da isplanirate svoje vrijeme i dostavite robu na vrijeme
apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Offline Invoices,Sinhronizuj offline fakture
DocType: BOM,Manufacturing,Proizvodnja
apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Isporučeno
DocType: Delivery Note,Customer's Purchase Order No,Broj porudžbenice kupca
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,U tabelu iznad unesite prodajni nalog
DocType: Quality Inspection,Report Date,Datum izvještaja
DocType: POS Profile,Item Groups,Vrste artikala
DocType: Pricing Rule,Discount Percentage,Procenat popusta
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Gross Profit %,Bruto dobit%
DocType: Payment Request,Payment Request,Upit za plaćanje
,Purchase Analytics,Analiza nabavke
DocType: Land Unit,Tree Details,Detalji stabla
DocType: Upload Attendance,Upload Attendance,Priloži evidenciju
DocType: Grant Application,Requested Amount,Traženi iznos
apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Snimanje svih komunikacija tipa email, telefon, poruke, posjete, itd."
DocType: Purchase Order,Customer Contact Email,Kontakt e-mail kupca
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Iznad
DocType: Item,Variant Based On,Varijanta zasnovana na
DocType: Project,Task Weight,Težina zadataka
DocType: Payment Entry,Transaction ID,Transakcije
DocType: Payment Entry Reference,Allocated,Dodijeljeno
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +171,Add more items or open full form,Dodaj još stavki ili otvori kompletan prozor
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Rezervisana za prodaju
DocType: POS Item Group,Item Group,Vrste artikala
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Starost (Dani)
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Dr),Početno stanje (Du)
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 krenite sa radom u programu
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Artikal {0} se javlja više puta u cjenovniku {1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +488,Production Order {0} must be submitted,Proizvodna porudžbine {0} mora biti potvrdjena
DocType: Customer,From Lead,Od Lead-a
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Baza potencijalnih kupaca
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Status Projekta
apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Sve vrste artikala
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serijski broj {0} ne postoji
apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Još uvijek nema dodatih kontakata
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Opseg dospijeća 3
DocType: Request for Quotation,Request for Quotation,Zahtjev za ponudu
DocType: Payment Entry,Account Paid To,Račun plaćen u
DocType: Stock Entry,Sales Invoice No,Broj fakture prodaje
apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Potrošeno vrijeme
DocType: Sales Invoice Item,Available Qty at Warehouse,Dostupna količina na skladištu
DocType: Item,Foreign Trade Details,Spoljnotrgovinski detalji
DocType: Item,Minimum Order Qty,Minimalna količina za poručivanje
DocType: Budget,Fiscal Year,Fiskalna godina
DocType: Stock Entry,Repack,Prepakovati
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,Izaberite skladište
DocType: Project,Project will be accessible on the website to these users,Projekat će biti dostupan na sajtu sledećim korisnicima
DocType: Upload Attendance,Upload HTML,Priloži HTML
apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Usluge
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Korpa sa artiklima
DocType: Warehouse,Warehouse Detail,Detalji o skldištu
DocType: Quotation Item,Quotation Item,Stavka sa ponude
DocType: Purchase Order Item,Warehouse and Reference,Skladište i veza
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Nalog {2} je neaktivan
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Fiskalna godina {0} nije pronađena
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Nema napomene
DocType: Notification Control,Purchase Receipt Message,Poruka u Prijemu robe
DocType: Purchase Invoice,Taxes and Charges Deducted,Umanjeni porezi i naknade
apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Izaberite brend
DocType: Item,Default Unit of Measure,Podrazumijevana jedinica mjere
DocType: Purchase Invoice Item,Serial No,Serijski broj
DocType: Pricing Rule,Supplier Type,Tip dobavljača
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Trenutna kol. {0} / Na čekanju {1}
DocType: Grant Application,Individual,Fizičko lice
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,Djelimično poručeno
DocType: Bank Reconciliation Detail,Posting Date,Datum dokumenta
DocType: Cheque Print Template,Date Settings,Podešavanje datuma
DocType: Payment Entry,Total Allocated Amount (Company Currency),Ukupan povezani iznos (Valuta)
DocType: Account,Income,Prihod
apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Dodaj stavke
apps/erpnext/erpnext/accounts/page/pos/pos.js +1707,Price List not found or disabled,Cjenovnik nije pronađen ili je zaključan
DocType: Vital Signs,Weight (In Kilogram),Težina (u kg)
apps/erpnext/erpnext/accounts/page/pos/pos.js +781,New Sales Invoice,Nova faktura
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Novo preduzeće
DocType: Issue,Support Team,Tim za podršku
DocType: Item,Valuation Method,Način vrednovanja
DocType: Project,Project Type,Tip Projekta
DocType: Purchase Order Item,Returned Qty,Vraćena kol.
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Iznos dodatnog popusta (valuta preduzeća)
DocType: Asset,Maintenance,Održavanje
DocType: Item Price,Multiple Item prices.,Više cijena artikala
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Received From,je primljen od
DocType: Payment Entry,Write Off Difference Amount,Otpis razlike u iznosu
DocType: Task,Closing Date,Datum zatvaranja
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Izaberite ljekara ...
DocType: Payment Entry,Cheque/Reference Date,Datum izvoda
DocType: Production Plan Item,Planned Qty,Planirana količina
DocType: Repayment Schedule,Payment Date,Datum plaćanja
DocType: Vehicle,Additional Details,Dodatni detalji
DocType: Company,Create Chart Of Accounts Based On,Kreiraj kontni plan prema
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Otvori To Do
DocType: Authorization Rule,Average Discount,Prosječan popust
DocType: Item,Material Issue,Reklamacija robe
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Ponuda dobavljaču {0} је kreirana
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Nije dozvoljeno mijenjati Promjene na zalihama starije od {0}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Dodaj zaposlene
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95,Warehouse not found in the system,Skladište nije pronađeno u sistemu
,Lab Test Report,Izvještaj labaratorijskog testa
DocType: Sales Invoice,Customer Name,Naziv kupca
DocType: Employee,Current Address,Trenutna adresa
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Predstojeći događaji u kalendaru
DocType: Accounts Settings,Make Payment via Journal Entry,Kreiraj uplatu kroz knjiženje
DocType: Payment Request,Paid,Plaćeno
DocType: Pricing Rule,Buying,Nabavka
DocType: Stock Settings,Default Item Group,Podrazumijevana vrsta artikala
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Na zalihama
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Umanjeni porezi i naknade (valuta preduzeća)
DocType: Stock Entry,Additional Costs,Dodatni troškovi
DocType: Project Task,Pending Review,Čeka provjeru
DocType: Item,Default Selling Cost Center,Podrazumijevani centar troškova
apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Još uvijek nema kupaca!
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +851,Sales Return,Povraćaj prodaje
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Ovo je zasnovano na transkcijama ovog klijenta. Pogledajte vremensku liniju ispod za dodatne informacije
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,Kreiraj potrošeno vrijeme
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozorenje: Prodajni nalog {0}već postoji veza sa porudžbenicom kupca {1}
DocType: Healthcare Settings,Healthcare Settings,Podešavanje klinike
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Analitička kartica
DocType: Stock Entry,Total Outgoing Value,Ukupna vrijednost isporuke
apps/erpnext/erpnext/controllers/selling_controller.py +248,Sales Order {0} is {1},Prodajni nalog {0} је {1}
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Podesi automatski serijski broj da koristi FIFO
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Novi kupci
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Prije prodaje
DocType: POS Customer Group,POS Customer Group,POS grupa kupaca
DocType: Quotation,Shopping Cart,Korpa sa sajta
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Rezervisana za proizvodnju
DocType: Pricing Rule,Pricing Rule Help,Pravilnik za cijene pomoć
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Opseg dospijeća 2
DocType: POS Item Group,POS Item Group,POS Vrsta artikala
DocType: Lead,Lead,Lead
apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Pogledajte sve proizvode
DocType: Patient Medical Record,Patient Medical Record,Medicinski karton pacijenta
DocType: Supplier,Address and Contacts,Adresa i kontakti
apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Ovo je zasnovano na transkcijama ovog preduzeća. Pogledajte vremensku liniju ispod za dodatne informacije
DocType: Student Attendance Tool,Batch,Serija
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +843,Purchase Receipt,Prijem robe
DocType: Item,Warranty Period (in days),Garantni rok (u danima)
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Korisnička baza podataka
,Stock Projected Qty,Projektovana količina na zalihama
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Kreiraj plaćanje
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 obrisati fiskalnu godinu {0}. Fiskalna  {0} godina je označena kao trenutna u globalnim podešavanjima.
apps/erpnext/erpnext/stock/stock_ledger.py +375,{0} units of {1} needed in {2} to complete this transaction.,Željenu količinu {0} za artikal {1} je potrebno dodati na {2} da bi dovršili transakciju..
DocType: Item Tax,Tax Rate,Poreska stopa
DocType: GL Entry,Remarks,Napomena
DocType: Opening Invoice Creation Tool,Sales,Prodaja
DocType: Pricing Rule,Pricing Rule,Pravilnik za cijene
DocType: Products Settings,Products Settings,Podešavanje proizvoda
DocType: Lab Test,Mobile,Mobilni
DocType: Purchase Invoice Item,Price List Rate,Cijena
apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Vrijednost popusta
,Sales Invoice Trends,Trendovi faktura prodaje
DocType: POS Profile,Apply Discount,Primijeni popust
DocType: Purchase Invoice,Tax Breakup,Porez po pozicijama
DocType: Asset Maintenance Log,Task,Zadatak
apps/erpnext/erpnext/stock/doctype/item/item.js +268,Add / Edit Prices,Dodaj / Izmijeni cijene
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +952,Production Order already created for all items with BOM,Proizvodna porudžbina je već kreirana za sve artikle sa BOM
,Item Prices,Cijene artikala
DocType: Salary Component,Salary Component,Компонента плате
DocType: Sales Order,Customer's Purchase Order Date,Datum porudžbenice kupca
DocType: Item,Country of Origin,Zemlja porijekla
DocType: Quotation,Order Type,Vrsta porudžbine
DocType: BOM Item,Rate & Amount,Cijena i iznos sa rabatom
apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Priloži evidenciju iz .csv datoteke
DocType: Pricing Rule,For Price List,Za cjenovnik
DocType: Purchase Invoice,Tax ID,Poreski broj
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,Wip skladište
,Itemwise Recommended Reorder Level,Pregled preporučenih nivoa dopune
,Requested Items To Be Ordered,Tražene stavke za isporuku
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +572,Sales Order {0} is not submitted,Prodajni nalog {0} nije potvrđen
DocType: Item,Default Material Request Type,Podrazumijevani zahtjev za tip materijala
apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,Prodajna linija
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +617,Already completed,Već završen
DocType: Sales Order Item,Ordered Qty,Poručena kol
DocType: Payment Entry,Pay,Plati
apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Shortage,Manjak
DocType: Item,Sales Details,Detalji prodaje
apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigacija
apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Vaši artikli ili usluge
DocType: Lead,CRM,CRM
apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Brend
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Ponuda {0} je otkazana
DocType: Pricing Rule,Item Code,Šifra artikla
DocType: Purchase Order,Customer Mobile No,Broj telefona kupca
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +75,Reorder Qty,Kol. za dopunu
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +110,Move Item,Premještanje artikala
DocType: Buying Settings,Buying Settings,Podešavanja nabavke
DocType: Driver,Fleet Manager,Menadžer transporta
apps/erpnext/erpnext/stock/doctype/batch/batch.js +43,Stock Levels,Nivoi zalihe
DocType: Sales Invoice Item,Rate With Margin (Company Currency),Cijena sa popustom (Valuta preduzeća)
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +253,Closing (Cr),Saldo (Po)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Sastavnica
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Prodaja i povraćaji
apps/erpnext/erpnext/accounts/page/pos/pos.js +786,Sync Master Data,Sinhronizuj podatke iz centrale
DocType: Landed Cost Voucher,Purchase Receipts,Prijemi robe
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Prilagođavanje formi
DocType: Project,% Complete Method,% metod vrednovanja završetka projekta
DocType: Purchase Invoice,Overdue,Istekao
DocType: Purchase Invoice,Posting Time,Vrijeme izrade računa
DocType: Stock Entry,Purchase Receipt No,Broj prijema robe
apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,do
DocType: Project,Expected End Date,Očekivani datum završetka
apps/erpnext/erpnext/projects/doctype/project/project.py +72,Expected End Date can not be less than Expected Start Date,Očekivani datum završetka ne može biti manji od očekivanog dana početka
DocType: Project,Expected Start Date,Očekivani datum početka
DocType: Supplier,Credit Limit,Kreditni limit
DocType: Item,Item Tax,Porez
DocType: Pricing Rule,Selling,Prodaja
DocType: Purchase Order,Customer Contact,Kontakt kupca
apps/erpnext/erpnext/stock/doctype/item/item.py +521,Item {0} does not exist,Artikal {0} ne postoji
apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Dodaj korisnike
,Completed Production Orders,Završena proizvodna porudžbina
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Izaberite serijske brojeve
DocType: Bank Reconciliation Detail,Payment Entry,Uplate
DocType: Purchase Invoice,In Words,Riječima
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serijski broj {0} ne pripada otpremnici {1}
DocType: Issue,Support,Podrška
DocType: Production Planning Tool,Get Sales Orders,Pregledaj prodajne naloge
DocType: Stock Ledger Entry,Stock Ledger Entry,Unos zalihe robe
apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Gantov grafikon svih zadataka
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Cijena (Valuta preduzeća)
DocType: Delivery Stop,Address Name,Naziv adrese
DocType: Item Group,Item Group Name,Naziv vrste artikala
apps/erpnext/erpnext/selling/doctype/customer/customer.py +146,A Customer Group exists with same name please change the Customer name or rename the Customer Group,Isto ime grupe kupca već postoji. Promijenite ime kupca ili izmijenite grupu kupca
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +540,Warning: Another {0} # {1} exists against stock entry {2},Upozorenje: Još jedan  {0} # {1} postoji u vezanom Unosu zaliha {2}
DocType: Item,Has Serial No,Ima serijski broj
DocType: Payment Entry,Difference Amount (Company Currency),Razlika u iznosu (Valuta)
apps/erpnext/erpnext/public/js/utils.js +49,Add Serial No,Dodaj serijski broj
apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Preduzeće i računi
DocType: Employee,Current Address Is,Trenutna adresa je
DocType: Payment Entry,Unallocated Amount,Nepovezani iznos
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Prikaži vrijednosti sa nulom
DocType: Purchase Invoice,Address and Contact,Adresa i kontakt
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Zakazivanja i pregledi
,Supplier-Wise Sales Analytics,Analiza Dobavljačeve pametne prodaje
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,Uplata je već kreirana
DocType: Purchase Invoice Item,Item,Artikal
DocType: Purchase Invoice,Unpaid,Neplaćen
DocType: Purchase Invoice Item,Net Rate,Neto cijena sa rabatom
DocType: Project User,Project User,Projektni user
DocType: Item,Customer Items,Proizvodi kupca
DocType: Stock Reconciliation,SR/,SR /
apps/erpnext/erpnext/stock/doctype/item/item.py +729,Item {0} is cancelled,Stavka {0} je otkazana
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Balance Value,Stanje vrijed.
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Prodajni nalog je obavezan za artikal {0}
DocType: Consultation,Patient,Pacijent
DocType: Stock Entry,Default Target Warehouse,Prijemno skladište
DocType: GL Entry,Voucher No,Br. dokumenta
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,Serijski broj {0} kreiran
DocType: Account,Asset,Osnovna sredstva
DocType: Payment Entry,Received Amount,Iznos uplate
,Sales Funnel,Prodajni lijevak
DocType: Sales Invoice,Payment Due Date,Datum dospijeća fakture
DocType: Consultation,Consultation,Pregled
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,Povezan
DocType: Warehouse,Warehouse Name,Naziv skladišta
DocType: Authorization Rule,Customer / Item Name,Kupac / Naziv proizvoda
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,Prijem vrije.
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Tip stabla
DocType: Stock Entry,Update Rate and Availability,Izmijenite cijenu i dostupnost
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +970,Supplier Quotation,Ponuda dobavljača
DocType: Material Request Item,Quantity and Warehouse,Količina i skladište
DocType: Purchase Invoice,Taxes and Charges Added,Porezi i naknade dodate
DocType: Production Order,Warehouses,Skladišta
DocType: SMS Center,All Customer Contact,Svi kontakti kupca
apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Glavna knjiga
DocType: Quotation,Quotation Lost Reason,Razlog gubitka ponude
DocType: Purchase Invoice,Return Against Purchase Invoice,Povraćaj u vezi sa Fakturom nabavke
DocType: Sales Invoice Item,Brand Name,Naziv brenda
DocType: Account,Stock,Zalihe
DocType: Customer Group,Customer Group Name,Naziv grupe kupca
DocType: Item,Is Sales Item,Da li je prodajni artikal
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Fakturisano
DocType: Purchase Invoice,Edit Posting Date and Time,Izmijeni datum i vrijeme dokumenta
,Inactive Customers,Neaktivni kupci
DocType: Stock Entry Detail,Stock Entry Detail,Detalji unosa zaliha
DocType: Sales Invoice,Accounting Details,Računovodstveni detalji
DocType: Asset Movement,Stock Manager,Menadžer zaliha
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Na datum
DocType: Serial No,Is Cancelled,Je otkazan
DocType: Naming Series,Setup Series,Podešavanje tipa dokumenta
,Point of Sale,Kasa
,Open Production Orders,Otvorene proizvodne porudžbine
DocType: Landed Cost Item,Purchase Receipt Item,Stavka Prijema robe
DocType: Project,Task Progress,% završenosti zadataka
DocType: Salary Slip,Payment Days,Dana za plaćanje
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Uslovi i odredbe šablon
apps/erpnext/erpnext/stock/doctype/batch/batch.js +97,Stock Entry {0} created,Unos zaliha {0} je kreiran
apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Pogledajte u korpi
apps/erpnext/erpnext/stock/get_item_details.py +350,Item Price updated for {0} in Price List {1},Cijena artikla je izmijenjena {0} u cjenovniku {1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +544,Discount,Popust
DocType: Packing Slip,Net Weight UOM,Neto težina  JM
DocType: Selling Settings,Sales Order Required,Prodajni nalog je obavezan
apps/erpnext/erpnext/accounts/page/pos/pos.js +1084,Search Item,Pretraži artikal
,Delivered Items To Be Billed,Nefakturisana isporučena roba
DocType: Account,Debit,Duguje
DocType: Patient Appointment,Date TIme,Datum i vrijeme
DocType: Bank Reconciliation Detail,Payment Document,Dokument za plaćanje
DocType: Purchase Invoice,In Words (Company Currency),Riječima (valuta kompanije)
,Purchase Receipt Trends,Trendovi prijema robe
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Fiskalna godina {0} ne postoji
DocType: Purchase Invoice Item,Accepted Warehouse,Prihvaćeno skladište
DocType: Account,Income Account,Račun prihoda
DocType: Journal Entry Account,Account Balance,Knjigovodstveno stanje
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/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Početna količina
DocType: Item,Reorder level based on Warehouse,Nivo dopune u zavisnosti od skladišta
apps/erpnext/erpnext/stock/doctype/batch/batch.js +76,To Warehouse,U skladište
DocType: Account,Is Group,Je grupa
DocType: Purchase Invoice,Contact Person,Kontakt osoba
DocType: Item,Item Code for Suppliers,Dobavljačeva šifra
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,Return / Debit Note,Povraćaj / knjižno zaduženje
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Zahtjev za ponudu dobavljača
,LeaderBoard,Tabla
DocType: Lab Test Groups,Lab Test Groups,Labaratorijske grupe
apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Bakarstvo i plaćanja
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Активни Леадс / Kupci
DocType: POS Profile,Accounting,Računovodstvo
DocType: Item,Manufacture,Proizvodnja
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Novi zadatak
DocType: Journal Entry,Accounts Payable,Obaveze prema dobavljačima
DocType: Purchase Invoice,Shipping Address,Adresa isporuke
DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Preostalo za uplatu
DocType: Physician,Physician Schedule,Raspored ljekara
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Skladište je potrebno unijeti na poziciji {0}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Naziv novog skladišta
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Stanje zalihe
,Item Shortage Report,Izvještaj o negativnim zalihama
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,Transaction reference no {0} dated {1},Broj izvoda {0} na datum {1}
apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Kreiraj prodajni nalog
DocType: Purchase Invoice,Items,Artikli
DocType: Payment Entry,Allocate Payment Amount,Poveži uplaćeni iznos
DocType: Patient,Patient ID,ID pacijenta
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +97,Printed On,Datum i vrijeme štampe
DocType: Sales Invoice,Debit To,Zaduženje za
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globalna podešavanja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +148,Atleast one warehouse is mandatory,Minimum jedno skladište je obavezno
DocType: Price List,Price List Name,Naziv cjenovnika
DocType: Item,Purchase Details,Detalji kupovine
DocType: Asset,Journal Entry for Scrap,Knjiženje rastura i loma
DocType: Item,Website Warehouse,Skladište web sajta
DocType: Sales Invoice Item,Customer's Item Code,Šifra kupca
DocType: Pricing Rule,Supplier,Dobavljači
DocType: Purchase Invoice,Additional Discount Amount,Iznos dodatnog popusta
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Datum početka projekta
DocType: Announcement,Student,Student
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,Prijem količine
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56,Selling Rate,Prodajna cijena
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Uvoz uspješan!
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +454,Stock cannot be updated against Delivery Note {0},Zaliha se ne može promijeniti jer je vezana sa otpremnicom {0}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +483,Form View,Prikaži kao formu
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Manjak kol.
DocType: Drug Prescription,Hour,Sat
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Stablo vrste artikala
DocType: POS Profile,Update Stock,Ažuriraj zalihu
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Kreiraj iz pregleda
DocType: Crop,Target Warehouse,Ciljno skladište
,Delivery Note Trends,Trendovi Otpremnica
DocType: Stock Entry,Default Source Warehouse,Izdajno skladište
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Sva skladišta
DocType: Stock Reconciliation,Difference Amount,Razlika u iznosu
DocType: Journal Entry,User Remark,Korisnička napomena
DocType: Notification Control,Quotation Message,Ponuda - poruka
DocType: Journal Entry,Stock Entry,Unos zaliha
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Prodajni cjenovnik
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Avg. Selling Rate,Prosječna prodajna cijena
DocType: Item,End of Life,Kraj proizvodnje
DocType: Payment Entry,Payment Type,Vrsta plaćanja
DocType: Selling Settings,Default Customer Group,Podrazumijevana grupa kupaca
DocType: GL Entry,Party,Partija
,Total Stock Summary,Ukupan pregled zalihe
DocType: Purchase Invoice,Net Total (Company Currency),Ukupno bez PDV-a (Valuta preduzeća)
DocType: Healthcare Settings,Patient Name,Ime pacijenta
apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Otpisati
DocType: Bank Guarantee,Start Date,Datum početka
DocType: Notification Control,Delivery Note Message,Poruka na otpremnici
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Ne može se obrisati serijski broj {0}, dok god se nalazi u dijelu Promjene na zalihama"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +575,Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena
apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Kupci na čekanju
DocType: Purchase Invoice,Price List Currency,Valuta Cjenovnika
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Projektni menadzer
DocType: Journal Entry,Accounts Receivable,Potraživanja od kupaca
DocType: Purchase Invoice Item,Rate,Cijena sa popustom
DocType: Project Task,View Task,Pogledaj zadatak
DocType: Account,Expense,Rashod
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Newsletter-i
DocType: Purchase Invoice,Select Supplier Address,Izaberite adresu dobavljača
apps/erpnext/erpnext/stock/get_item_details.py +365,Price List {0} is disabled or does not exist,Cjenovnik {0} je zaključan ili ne postoji
DocType: Delivery Note,Billing Address Name,Naziv adrese za naplatu
DocType: Restaurant Order Entry,Add Item,Dodaj stavku
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Sve grupe kupca
DocType: Purchase Invoice Item,Weight UOM,JM Težina
DocType: Purchase Invoice Item,Stock Qty,Zaliha
DocType: Delivery Note,Return Against Delivery Note,Povraćaj u vezi sa otpremnicom
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Opseg dospijeća 1
DocType: Serial No,Incoming Rate,Nabavna cijena
apps/erpnext/erpnext/hooks.py +144,Timesheets,Potrošnja vremena
apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,Artikli na zalihama
apps/erpnext/erpnext/accounts/page/pos/pos.js +2181,New Cart,Nova korpa
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +66,Opening Value,Početna vrijednost
apps/erpnext/erpnext/config/selling.py +179,Analytics,Analitika
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +237,New {0}: #{1},Novi {0}: # {1}
DocType: Company,Fixed Days,Fiksni dani
DocType: Purchase Receipt Item,Rate and Amount,Cijena i vrijednost sa popustom
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +71,'Total','Ukupno bez PDV-a'
DocType: Purchase Invoice,Total Taxes and Charges,Porez
DocType: Purchase Order Item,Supplier Part Number,Dobavljačeva šifra
DocType: Project Task,Project Task,Projektni zadatak
DocType: Item Group,Parent Item Group,Nadređena Vrsta artikala
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,Kreirao je korisnik {0}
DocType: Purchase Order,Advance Paid,Avansno plačanje
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Nivo dopune
DocType: Opportunity,Customer / Lead Address,Kupac / Adresa lead-a
DocType: Buying Settings,Default Buying Price List,Podrazumijevani Cjenovnik
DocType: Purchase Invoice Item,Qty,Kol
DocType: Mode of Payment,General,Opšte
DocType: Supplier,Default Payable Accounts,Podrazumijevani nalog za plaćanje
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Cijena: {0}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1463,Write Off Amount,Otpisati iznos
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Preostalo za plaćanje
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Nije plaćeno i nije isporučeno
DocType: Asset Maintenance Log,Planned,Planirano
DocType: Bank Reconciliation,Total Amount,Ukupan iznos
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +160,Please select Price List,Izaberite cjenovnik
DocType: Quality Inspection,Item Serial No,Seriski broj artikla
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Usluga kupca
DocType: Project Task,Working,U toku
DocType: Cost Center,Stock User,Korisnik zaliha
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Glavna knjiga
apps/erpnext/erpnext/config/projects.py +13,Project master.,Projektni master
DocType: Pricing Rule,Valid From,Važi od
,Purchase Order Trends,Trendovi kupovina
DocType: Quotation,In Words will be visible once you save the Quotation.,Sačuvajte Predračun da bi Ispis slovima bio vidljiv
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Projektovana količina
apps/erpnext/erpnext/config/selling.py +229,Customer Addresses And Contacts,Kontakt i adresa kupca
DocType: Material Request Item,For Warehouse,Za skladište
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Nabavni cjenovnik
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Izaberite ljekara i datum
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Pregled obaveze prema dobavljačima
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Otpremnice {0} moraju biti otkazane prije otkazivanja prodajnog naloga
DocType: Employee Loan,Total Payment,Ukupno plaćeno
DocType: POS Settings,POS Settings,POS podešavanja
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Iznos nabavke
DocType: Purchase Invoice Item,Valuation Rate,Prosječna nab. cijena
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID Projekta
DocType: Journal Entry Account,Purchase Order,Porudžbenica
DocType: Sales Invoice Item,Rate With Margin,Cijena sa popustom
DocType: GL Entry,Voucher Type,Vrsta dokumenta
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serijski broj {0} je već primljen
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Uvoz i izvoz podataka
apps/erpnext/erpnext/controllers/accounts_controller.py +540,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupan avns({0}) na porudžbini {1} ne može biti veći od Ukupnog iznosa ({2})
DocType: Material Request,% Ordered,%  Poručenog
apps/erpnext/erpnext/stock/get_item_details.py +367,Price List not selected,Cjenovnik nije odabran
DocType: POS Profile,Apply Discount On,Primijeni popust na
DocType: Item,Total Projected Qty,Ukupna projektovana količina
DocType: Shipping Rule Condition,Shipping Rule Condition,Uslovi  pravila nabavke
apps/erpnext/erpnext/config/stock.py +310,Opening Stock Balance,Početno stanje zalihe
,Customer Credit Balance,Kreditni limit kupca
apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Adresa još nije dodata.
DocType: C-Form Invoice Detail,Net Total,Ukupno bez PDV-a
DocType: Purchase Invoice,Return,Povraćaj
DocType: Sales Order Item,Delivery Warehouse,Skladište dostave
DocType: Purchase Invoice,Total (Company Currency),Ukupno bez PDV-a (Valuta)
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1024,Opportunity,Prilika
DocType: Sales Order,Fully Delivered,Kompletno isporučeno
DocType: Customer,Default Price List,Podrazumijevani cjenovnik
DocType: Journal Entry,Journal Entry,Knjiženje
DocType: Purchase Invoice,Apply Additional Discount On,Primijeni dodatni popust na
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Ovo je zasnovano na transkcijama ovog dobavljača. Pogledajte vremensku liniju ispod za dodatne informacije
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,Iznad 90 dana
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +871,Serial Numbers in row {0} does not match with Delivery Note,Serijski broj na poziciji {0} se ne poklapa sa otpremnicom
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Novi kontakt
DocType: Production Planning Tool,Create Production Orders,Kreiraj porudžbinu za proizvodnju
DocType: Purchase Invoice,Returns,Povraćaj
DocType: Delivery Note,Delivery To,Isporuka za
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Vrijednost Projekta
DocType: Warehouse,Parent Warehouse,Nadređeno skladište
DocType: Payment Request,Make Sales Invoice,Kreiraj fakturu prodaje
apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,Obriši
apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Izaberite skladište...
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Detalji knjiženja
,Projected Quantity as Source,Projektovana izvorna količina
DocType: Asset Maintenance,Manufacturing User,Korisnik u proizvodnji
apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Kreiraj korisnike
DocType: Pricing Rule,Price,Cijena
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Izdavanje Kol.
DocType: Supplier Scorecard Scoring Standing,Employee,Zaposleni
apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Projektna aktivnost / zadatak
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervisano skladište u Prodajnom nalogu / Skladište gotovog proizvoda
DocType: Appointment Type,Physician,Ljekar
DocType: Opening Invoice Creation Tool Item,Quantity,Količina
DocType: Buying Settings,Purchase Receipt Required,Prijem robe je obavezan
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Valuta je obavezna za Cjenovnik {0}
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,Izdavanje vrije.
DocType: POS Customer Group,Customer Group,Grupa kupaca
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Skladište se jedino može promijeniti u dijelu Unos zaliha / Otpremnica / Prijem robe
apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Zahtjev za ponude
apps/erpnext/erpnext/config/desktop.py +167,Learn,Naučite
DocType: POS Profile,Ignore Pricing Rule,Zanemari pravilnik o cijenama
DocType: Purchase Invoice,Additional Discount,Dodatni popust
DocType: Payment Entry,Cheque/Reference No,Broj izvoda
DocType: C-Form,Series,Vrsta dokumenta
apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Kutija
DocType: Payment Entry,Total Allocated Amount,Ukupno povezani iznos
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Sve adrese
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Korisnici i dozvole
apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Dodaj kupce
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Otpremite robu prvo
DocType: Lead,From Customer,Od kupca
DocType: Item,Maintain Stock,Vođenje zalihe
DocType: Sales Invoice Item,Sales Order Item,Pozicija prodajnog naloga
apps/erpnext/erpnext/public/js/utils.js +100,Annual Billing: {0},Godišnji promet: {0}
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Rezervisana kol.
apps/erpnext/erpnext/accounts/page/pos/pos.js +1743,Not items found,Ništa nije pronađeno
DocType: Item,Copy From Item Group,Kopiraj iz vrste artikala
DocType: Purchase Taxes and Charges,On Net Total,Na ukupno bez PDV-a
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% završen
apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} se ne nalazi u aktivnim poslovnim godinama.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +492,Quick Journal Entry,Brzo knjiženje
DocType: Sales Order,Partly Delivered,Djelimično isporučeno
DocType: Purchase Invoice Item,Quality Inspection,Provjera kvaliteta
apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,Računovodstveni iskazi
apps/erpnext/erpnext/stock/get_item_details.py +354,Item Price added for {0} in Price List {1},Cijena je dodata na artiklu {0} iz cjenovnika {1}
DocType: Project Type,Projects Manager,Projektni menadžer
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Ponuda {0} ne propada {1}
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Svi proizvodi ili usluge.
DocType: Purchase Invoice,Rounded Total,Zaokruženi ukupan iznos
DocType: Request for Quotation Supplier,Download PDF,Preuzmi PDF
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +913,Quotation,Ponuda
DocType: Lead,Mobile No.,Mobilni br.
DocType: Item,Has Variants,Ima varijante
DocType: Price List Country,Price List Country,Zemlja cjenovnika
apps/erpnext/erpnext/controllers/accounts_controller.py +136,Due Date is mandatory,Datum dospijeća je obavezan
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Korpa
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Promjene na zalihama prije {0} su zamrznute
apps/erpnext/erpnext/selling/doctype/customer/customer.py +193,Credit limit has been crossed for customer {0} {1}/{2},Kupac {0} je prekoračio kreditni limit {1} / {2}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Dr),Saldo (Du)
DocType: Sales Invoice,Product Bundle Help,Sastavnica Pomoć
apps/erpnext/erpnext/accounts/report/financial_statements.py +233,Total {0} ({1}),Ukupno bez PDV-a {0} ({1})
DocType: Sales Partner,Address & Contacts,Adresa i kontakti
apps/erpnext/erpnext/controllers/accounts_controller.py +312, or ,ili
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Zahtjev za ponudu
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standardna prodaja
DocType: Employee Advance,Expense Approver,Odobravatalj troškova
DocType: Purchase Invoice,Supplier Invoice Details,Detalji sa fakture dobavljača
DocType: Purchase Order,To Bill,Za fakturisanje
apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Gant dijagram
DocType: Bin,Requested Quantity,Tražena količina
DocType: Company,Chart Of Accounts Template,Templejt za kontni plan
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Ljekar {0} nije dostupan {1}
DocType: Payment Entry Reference,Supplier Invoice No,Broj fakture dobavljača
apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Globalna podešavanja za cjelokupan proces proizvodnje.
DocType: Stock Entry,Material Transfer for Manufacture,Пренос robe za proizvodnju
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Vezni dokument
DocType: Account,Accounts,Računi
,Requested,Tražena
apps/erpnext/erpnext/controllers/buying_controller.py +414,{0} {1} is cancelled or closed,{0} {1} je otkazan ili zatvoren
DocType: Request for Quotation Item,Request for Quotation Item,Zahtjev za stavku sa ponude
DocType: Homepage,Products,Proizvodi
DocType: Patient Appointment,Check availability,Provjeri dostupnost
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Potrošeno vrijeme je kreirano:
apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","npr. ""Izrada alata za profesionalce"""
apps/erpnext/erpnext/public/js/utils.js +102,Total Unpaid: {0},Ukupno neplaćeno: {0}
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Kreiraj Fakturu
DocType: Purchase Invoice,Is Paid,Je plaćeno
DocType: Manufacturing Settings,Material Transferred for Manufacture,Prenešena roba za proizvodnju
,Ordered Items To Be Billed,Poručeni artikli za fakturisanje
apps/erpnext/erpnext/config/selling.py +216,Other Reports,Ostali izvještaji
apps/erpnext/erpnext/config/buying.py +7,Purchasing,Kupovina
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +933,Delivery Note,Otpremnice
DocType: Sales Order,In Words will be visible once you save the Sales Order.,U riječima će biti vidljivo tek kada sačuvate prodajni nalog.
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Прикажи одсечак плате
DocType: Journal Entry Account,Sales Order,Prodajni nalog
DocType: Stock Entry,Customer or Supplier Details,Detalji kupca ili dobavljača
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Prodaja
DocType: Email Digest,Pending Quotations,Predračuni na čekanju
DocType: Purchase Invoice,Additional Discount Percentage,Dodatni procenat popusta
DocType: Appraisal,HR User,Korisnik za ljudske resure
apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Izvještaji zaliha robe
DocType: Sales Invoice,Return Against Sales Invoice,Povraćaj u vezi sa Fakturom prodaje
DocType: Buying Settings,Naming Series,Vrste dokumenta
,Stock Ledger,Skladišni karton
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Faktura {0} mora biti otkazana prije otkazivanja ovog prodajnog naloga
DocType: Email Digest,New Quotations,Nove ponude
apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Prvo sačuvajte dokument
DocType: Item,Units of Measure,Jedinica mjere
DocType: Antibiotic,Healthcare,Klinika
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Trenutna količina na zalihama
DocType: Quotation Item,Actual Qty,Trenutna kol.
