diff --git a/erpnext/translations/bs.csv b/erpnext/translations/bs.csv
index 11cb13f..e54ca04 100644
--- a/erpnext/translations/bs.csv
+++ b/erpnext/translations/bs.csv
@@ -3,12 +3,12 @@
 DocType: Patient,Divorced,Rastavljen
 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/setup/setup_wizard/industry_type.py +19,Consumer Products,Consumer Products
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Consumer Products
 DocType: Purchase Receipt,Subscription Detail,Detalji pretplate
 DocType: Supplier Scorecard,Notify Supplier,Obavijestiti dobavljača
 DocType: Item,Customer Items,Customer Predmeti
 DocType: Project,Costing and Billing,Cijena i naplata
-apps/erpnext/erpnext/accounts/doctype/account/account.py +52,Account {0}: Parent account {1} can not be a ledger,Konto {0}: Nadređeni konto {1} Ne može biti knjiga
+apps/erpnext/erpnext/accounts/doctype/account/account.py +48,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/config/setup.py +88,Email Notifications,E-mail obavijesti
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,procjena
@@ -20,10 +20,9 @@
 DocType: Restaurant Order Entry,Click Enter To Add,Kliknite Enter za dodavanje
 DocType: Employee,Rented,Iznajmljuje
 DocType: Purchase Order,PO-,PO-
-DocType: POS Profile,Applicable for User,Primjenjivo za korisnika
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +196,"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"
+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/accounts/doctype/asset/asset.js +220,Do you really want to scrap this asset?,Da li zaista želite da ukine ove imovine?
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +240,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/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Valuta je potreban za Cjenovnik {0}
@@ -32,8 +31,8 @@
 DocType: Patient Appointment,Check availability,Provjera dostupnosti
 DocType: Job Applicant,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
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +34,Legal,Pravni
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,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}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Pravni
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,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: Bank Guarantee,Customer,Kupci
 DocType: Purchase Receipt Item,Required By,Potrebna Do
 DocType: Delivery Note,Return Against Delivery Note,Vratiti protiv Isporuka Napomena
@@ -41,79 +40,91 @@
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Tečajna lista moraju biti isti kao {0} {1} ({2})
 DocType: Sales Invoice,Customer Name,Naziv kupca
 DocType: Vehicle,Natural Gas,prirodni gas
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +120,Bank account cannot be named as {0},Žiro račun ne može biti imenovan kao {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Žiro račun ne može biti imenovan kao {0}
 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 +196,Outstanding for {0} cannot be less than zero ({1}),Izvanredna za {0} ne može biti manji od nule ( {1} )
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +357,There are no submitted Salary Slips to process.,Nema podnesenih plata za obradu.
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Nema podnesenih plata za obradu.
 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/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Neophodno je i danas preduzeti ovu akciju za gore pomenuto ponavljanje
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Serija Updated uspješno
 apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Provjeri
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +175,Accural Journal Entry Submitted,Accural Journal Entry Postavio
 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 +70,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
+apps/erpnext/erpnext/projects/doctype/project/project.py +72,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
 apps/erpnext/erpnext/utilities/transaction_base.py +110,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Rate moraju biti isti kao {1}: {2} ({3} / {4})
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,Novi dopust Primjena
 ,Batch Item Expiry Status,Batch Stavka Status isteka
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +180,Bank Draft,Bank Nacrt
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Bank Nacrt
+DocType: Membership,membership validaty section,članak validaty sekcija
 DocType: Mode of Payment Account,Mode of Payment Account,Način plaćanja računa
 DocType: Consultation,Consultation,Konsultacije
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +21,Sales and Returns,Prodaja i povratak
+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 +19,Sales and Returns,Prodaja i povratak
 apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Show Varijante
 DocType: Academic Term,Academic Term,akademski Term
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,materijal
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +670,Quantity,Količina
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Računi stol ne može biti prazan.
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Pravljenje web stranice
+DocType: Opening Invoice Creation Tool Item,Quantity,Količina
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +544,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 +154,Loans (Liabilities),Zajmovi (pasiva)
 DocType: Employee Education,Year of Passing,Tekuća godina
 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 +24,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 +144,User {0} is already assigned to Employee {1},Korisnik {0} već dodijeljena zaposlenika {1}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,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/industry_type.py +31,Health Care,Zdravstvena zaštita
+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: Lab Prescription,Lab Prescription,Lab recept
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +185,Sort by Price,Sortiraj po cijeni
 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 +888,Serial Number: {0} is already referenced in Sales Invoice: {1},Serijski broj: {0} je već spomenut u prodaje Faktura: {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +849,Invoice,Faktura
-DocType: Maintenance Schedule Item,Periodicity,Periodičnost
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +893,Serial Number: {0} is already referenced in Sales Invoice: {1},Serijski broj: {0} je već spomenut u prodaje Faktura: {1}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Invoice,Faktura
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +109,Make Retention Stock Entry,Napravite zadržavanje zaliha zaliha
+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
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +21,Defense,Obrana
+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 +225,Row {0}: {1} {2} does not match with {3},Row {0}: {1} {2} ne odgovara {3}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +223,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 +75,Row # {0}:,Row # {0}:
 DocType: Timesheet,Total Costing Amount,Ukupno Costing iznos
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Klijent&gt; Grupa klijenata&gt; Teritorija
 DocType: Delivery Note,Vehicle No,Ne vozila
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +160,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 +78,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Isplata dokument je potrebno za završetak trasaction
 DocType: Production Order Operation,Work In Progress,Radovi u toku
-apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +13,Please select date,Molimo izaberite datum
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Molimo izaberite datum
 DocType: Employee,Holiday List,Lista odmora
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +123,Accountant,Računovođa
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Računovođa
 DocType: Hub Settings,Selling Price List,Prodajni cjenik
 DocType: Patient,Tobacco Current Use,Upotreba duvana
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +21,Selling Rate,Prodajna stopa
 DocType: Cost Center,Stock User,Stock korisnika
+DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
 DocType: Company,Phone No,Telefonski broj
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +50,Course Schedules created:,Rasporedi Course stvorio:
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +237,New {0}: #{1},Novi {0}: {1} #
+DocType: Delivery Trip,Initial Email Notification Sent,Poslato je prvo obaveštenje o e-mailu
 ,Sales Partners Commission,Prodaja Partneri komisija
+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 +45,Abbreviation cannot have more than 5 characters,Skraćeni naziv ne može imati više od 5 znakova
 DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Vremenski raspored lekara
 DocType: Payment Request,Payment Request,Plaćanje Upit
 DocType: Asset,Value After Depreciation,Vrijednost Nakon Amortizacija
-DocType: Employee,O+,O +
+DocType: Student,O+,O +
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,povezan
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,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
@@ -126,150 +137,154 @@
 apps/erpnext/erpnext/accounts/utils.py +73,{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/utilities/user_progress.py +125,Kg,kg
+apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,kg
 apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Otvaranje za posao.
-apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +147,{0} Result submittted,{0} Rezultat je podnet
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +103,BOM is not specified for subcontracting item {0} at row {1},BOM nije naveden za stavku podizvođača {0} na redu {1}
+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 +61,Timespan,Vremenski razmak
 apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Odaberite Warehouse ...
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +6,Advertising,Oglašavanje
+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 +44,Not permitted for {0},Nije dozvoljeno za {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +568,Get items from,Get stavke iz
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +457,Stock cannot be updated against Delivery Note {0},Dionica ne može biti obnovljeno protiv isporuke Napomena {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Get stavke iz
+DocType: Price List,Price Not UOM Dependant,Cena nije UOM zavisna
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +461,Stock cannot be updated against Delivery Note {0},Dionica ne može biti obnovljeno protiv isporuke Napomena {0}
 apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Proizvod {0}
 apps/erpnext/erpnext/templates/generators/item_group.html +43,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/industry_type.py +30,Grocery,Trgovina prehrambenom robom
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Trgovina prehrambenom robom
 DocType: Quality Inspection Reading,Reading 1,Čitanje 1
-DocType: Process Payroll,Make Bank Entry,Make Bank Entry
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +40,Pension Funds,mirovinskim fondovima
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Sljedeća Amortizacija datum ne može biti prije Datum kupovine
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,mirovinskim fondovima
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Sljedeća Amortizacija datum ne može biti prije Datum kupovine
+DocType: Crop,Perennial,Višegodišnje
 DocType: Consultation,Consultation Date,Datum konsultacije
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +131,Product listing and discovery for ERPNext users,Spisak proizvoda i otkrivanje za korisnike ERPNext
 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 +1727,Not items found,Nije pronađenim predmetima
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1742,Not items found,Nije pronađenim predmetima
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,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 +114,"e.g. ""Primary School"" or ""University""",npr &quot;Osnovna škola&quot; ili &quot;Univerzitet&quot;
-apps/erpnext/erpnext/config/stock.py +32,Stock Reports,Stock Izvještaji
+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/selling/doctype/customer/customer.py +164,Credit limit has been crossed for customer {0} {1}/{2},Kreditni limit je prešla za kupca {0} {1} / {2}
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,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 +479,"""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"
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +192,Credit limit has been crossed for customer {0} {1}/{2},Kreditni limit je prešla za kupca {0} {1} / {2}
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,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 +258,"""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
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Klijent&gt; Grupa klijenata&gt; Teritorija
 DocType: Tax Rule,Tax Type,Vrste poreza
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +555,Taxable Amount,oporezivi iznos
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +561,Taxable Amount,oporezivi iznos
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Niste ovlašteni za dodati ili ažurirati unose prije {0}
 DocType: BOM,Item Image (if not slideshow),Slika proizvoda (ako nije slide prikaz)
 DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Satnica / 60) * Puna radno vrijeme
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1050,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,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 +917,Select BOM,Izaberite BOM
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,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 +964,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/config/hr.py +127,Manage advance amount given to the Employee,Upravljaju iznos koji se daje zaposlenom
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,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: Student Log,Student Log,student Prijavite
 DocType: Quality Inspection,Get Specification Details,Kreiraj detalje specifikacija
 apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Šabloni pozicija dobavljača.
 DocType: Lead,Interested,Zainteresovan
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +171,Opening,Otvaranje
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +28,From {0} to {1},Od {0} do {1}
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +219,Opening,Otvaranje
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +29,From {0} to {1},Od {0} do {1}
+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: Delivery Trip,Delivery Notification,Obaveštenje o isporuci
 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: Employee 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 +141,Account with existing transaction can not be converted to group.,Konto sa postojećim transakcijama se ne može pretvoriti u grupu konta .
+apps/erpnext/erpnext/accounts/doctype/account/account.py +140,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: Academic Term,Schools,škole
-DocType: School Settings,Validate Batch for Students in Student Group,Potvrditi Batch za studente u Studentskom Group
+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 +35,No leave record found for employee {0} for {1},Nema odmora Snimanje pronađena za zaposlenog {0} za {1}
 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 +358,Please select Company first,Molimo najprije odaberite Company
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Company first,Molimo najprije odaberite Company
 DocType: Employee Education,Under Graduate,Pod diplomski
 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: Journal Entry Account,Employee Loan,zaposlenik kredita
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +108,Activity Log:,Dnevnik aktivnosti:
 DocType: Fee Schedule,Send Payment Request Email,Pošaljite zahtev za plaćanje
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +256,Item {0} does not exist in the system or has expired,Artikal {0} ne postoji u sustavu ili je istekao
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +44,Real Estate,Nekretnine
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +259,Item {0} does not exist in the system or has expired,Artikal {0} ne postoji u sustavu ili je istekao
+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/industry_type.py +41,Pharmaceuticals,Lijekovi
+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 +234,"Available qty is {0}, you need {1}","Dostupno Količina je {0}, potrebno je {1}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +251,"Available qty is {0}, you need {1}","Dostupno Količina je {0}, potrebno je {1}"
 DocType: Expense Claim Detail,Claim Amount,Iznos štete
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +51,Duplicate customer group found in the cutomer group table,Duplikat grupe potrošača naći u tabeli Cutomer grupa
+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
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Dobavljač Tip / Supplier
 DocType: Naming Series,Prefix,Prefiks
 apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Lokacija događaja
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +64,Consumable,Potrošni
-DocType: Employee,B-,B-
-DocType: Upload Attendance,Import Log,Uvoz Prijavite
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Potrošni
+DocType: Student,B-,B-
 DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Povucite Materijal Zahtjev tipa proizvoda na bazi navedene kriterije
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +100,Successfully unregistered.,Uspešno neregistrovani.
-DocType: Training Result Employee,Grade,razred
+DocType: Assessment Result,Grade,razred
 DocType: Restaurant Table,No of Seats,Broj sedišta
 DocType: Subscription,"To add dynamic subject, use jinja tags like
 
 <div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Da biste dodali dinamički predmet, koristite oznake tipa jinja <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
 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/selling/doctype/sales_order/sales_order.js +905,Production Order already created for all items with BOM,Proizvodnog naloga već stvorena za sve stavke sa BOM
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +220,Annual Salary,Godišnja zarada
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +952,Production Order already created for all items with BOM,Proizvodnog naloga već stvorena za sve stavke sa BOM
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +230,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 +368,{0} {1} is frozen,{0} {1} je smrznuto
-apps/erpnext/erpnext/setup/doctype/company/company.py +132,Please select Existing Company for creating Chart of Accounts,Molimo odaberite postojećeg društva za stvaranje Kontni plan
+apps/erpnext/erpnext/accounts/party.py +380,{0} {1} is frozen,{0} {1} je smrznuto
+apps/erpnext/erpnext/setup/doctype/company/company.py +129,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 +80,Stock Expenses,Stock Troškovi
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +96,Select Target Warehouse,Odaberite Target Skladište
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Odaberite Target Skladište
 apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Unesite Preferred Kontakt mail
-DocType: Program Enrollment,School Bus,Školski autobus
 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
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
 					<br>Absent: {1}",Da li želite da ažurirate prisustvo? <br> Prisutni: {0} \ <br> Odsutni: {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +325,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}
+apps/erpnext/erpnext/controllers/buying_controller.py +326,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: Request for Quotation,RFQ-,RFQ-
 DocType: Item,Supply Raw Materials for Purchase,Supply sirovine za kupovinu
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +149,At least one mode of payment is required for POS invoice.,Najmanje jedan način plaćanja je potreban za POS računa.
+DocType: Agriculture Analysis Criteria,Fertilizer,Đubrivo
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +150,At least one mode of payment is required for POS invoice.,Najmanje jedan način plaćanja je potreban za POS računa.
 DocType: Products Settings,Show Products as a List,Prikaži proizvode kao listu
-DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
-All dates and employee combination in the selected period will come in the template, with existing attendance records","Preuzmite Template, popunite odgovarajuće podatke i priložite modifikovani datoteku.
- Svi datumi i zaposlenog kombinacija u odabranom periodu doći će u predlošku, sa postojećim pohađanje evidencije"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +482,Item {0} is not active or end of life has been reached,Stavka {0} nije aktivan ili kraj života je postignut
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +507,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 +169,Example: Basic Mathematics,Primjer: Osnovni Matematika
-apps/erpnext/erpnext/controllers/accounts_controller.py +657,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","To uključuje porez u redu {0} u stopu točke , porezi u redovima {1} također moraju biti uključeni"
-apps/erpnext/erpnext/config/hr.py +218,Settings for HR Module,Podešavanja modula ljudskih resursa
+apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Primjer: Osnovni Matematika
+apps/erpnext/erpnext/controllers/accounts_controller.py +769,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","To uključuje porez u redu {0} u stopu točke , porezi u redovima {1} također moraju biti uključeni"
+apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Podešavanja modula ljudskih resursa
 DocType: SMS Center,SMS Center,SMS centar
 DocType: Sales Invoice,Change Amount,Promjena Iznos
 DocType: BOM Update Tool,New BOM,Novi BOM
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +117,Please enter Delivery Date,Molimo unesite datum isporuke
+DocType: Driver,Driving License Categories,Vozačke dozvole Kategorije
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Molimo unesite datum isporuke
 DocType: Depreciation Schedule,Make Depreciation Entry,Make Amortizacija Entry
 DocType: Appraisal Template Goal,KRA,KRA
 DocType: Lead,Request Type,Zahtjev Tip
 apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,Make zaposlenih
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +14,Broadcasting,radiodifuzija
-apps/erpnext/erpnext/config/accounts.py +321,Setup mode of POS (Online / Offline),Način podešavanja POS (Online / Offline)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +187,Execution,izvršenje
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,radiodifuzija
+apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Način podešavanja POS (Online / Offline)
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,izvršenje
 apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Detalji o poslovanju obavlja.
-DocType: Serial No,Maintenance Status,Održavanje statusa
+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: Drug Prescription,Interval,Interval
-DocType: Customer,Individual,Pojedinac
-DocType: Interest,Academics User,akademici korisnika
+DocType: Grant Application,Individual,Pojedinac
+DocType: Academic Term,Academics User,akademici korisnika
 DocType: Cheque Print Template,Amount In Figure,Iznos Na slici
 DocType: Employee Loan Application,Loan Info,kredit Info
 apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plan održavanja posjeta.
@@ -282,17 +297,19 @@
 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
 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/healthcare/setup.py +214,Biochemistry,Biokemija
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Šablon predmeta
+apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biokemija
 DocType: Offer Letter,Select Terms and Conditions,Odaberite uvjeti
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +60,Out Value,out vrijednost
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,out vrijednost
 DocType: Production Planning Tool,Sales Orders,Sales Orders
 DocType: Purchase Taxes and Charges,Valuation,Procjena
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +373,Set as Default,Postavi kao podrazumjevano
 ,Purchase Order Trends,Trendovi narudžbenica kupnje
 apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Idi na kupce
 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
 apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Dodijeli odsustva za godinu.
 DocType: SG Creation Tool Course,SG Creation Tool Course,SG Stvaranje Alat za golf
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +236,Insufficient Stock,nedovoljna Stock
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,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 Guarantee,Bank Account,Žiro račun
@@ -300,67 +317,69 @@
 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;
 DocType: Employee,Create User,Kreiranje korisnika
 DocType: Selling Settings,Default Territory,Zadani teritorij
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Televizija
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televizija
 DocType: Production Order Operation,Updated via 'Time Log',Ažurirano putem 'Time Log'
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +427,Advance amount cannot be greater than {0} {1},iznos Advance ne može biti veći od {0} {1}
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +428,Advance amount cannot be greater than {0} {1},iznos Advance ne može biti veći od {0} {1}
 DocType: Naming Series,Series List for this Transaction,Serija Popis za ovu transakciju
 DocType: Company,Enable Perpetual Inventory,Omogućiti vječni zaliha
 DocType: Company,Default Payroll Payable Account,Uobičajeno zarade plaćaju nalog
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +51,Update Email Group,Update-mail Group
+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: Supplier Scorecard,Criteria Setup,Postavljanje kriterijuma
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +179,For Warehouse is required before Submit,Jer je potrebno Warehouse prije Podnijeti
+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: Sales Partner,Reseller,Prodavač
 DocType: Codification Table,Medical Code,Medicinski kod
 DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Ako je označeno, će uključivati ne-stanju proizvodi u Industrijska zahtjevima."
 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
 ,Production Orders in Progress,Radni nalozi u tijeku
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Neto gotovine iz aktivnosti finansiranja
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2313,"LocalStorage is full , did not save","LocalStorage je puna, nije spasio"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2332,"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: Lab Test,Custom Result,Prilagođeni rezultat
-apps/erpnext/erpnext/utilities/user_progress.py +71,Contact Name,Kontakt ime
+DocType: Delivery Stop,Contact Name,Kontakt ime
 DocType: Course Assessment Criteria,Course Assessment Criteria,Kriteriji procjene naravno
-DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Stvara plaće slip za gore navedene kriterije.
 DocType: POS Customer Group,POS Customer Group,POS kupaca Grupa
+DocType: Land Unit,Land Unit describing various land assets,Zemaljska jedinica koja opisuje različite imovine zemljišta
 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/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Plan procjene:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Plan procjene:
 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: 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
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +390,Net Pay cannot be less than 0,Neto Pay ne može biti manja od 0
+DocType: Payment Term,Credit Months,Kreditni meseci
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Neto Pay ne može biti manja od 0
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Da biste zaustavili slanje ponavljajućih obaveštenja o greškama iz sistema, u pretplatu smo označili polje Disabled"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Samoodabrani Ostavite Odobritelj može podnijeti ovo ostaviti aplikacija
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Relieving Date must be greater than Date of Joining,Olakšavanja Datum mora biti veći od dana ulaska u
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +228,Leaves per Year,Ostavlja per Godina
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Molimo provjerite 'Je li Advance ""protiv Account {1} ako je to unaprijed unos."
-apps/erpnext/erpnext/stock/utils.py +212,Warehouse {0} does not belong to company {1},Skladište {0} ne pripada tvrtki {1}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,Olakšavanja Datum mora biti veći od dana ulaska u
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Leaves per Year,Ostavlja per Godina
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +128,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Molimo provjerite 'Je li Advance ""protiv Account {1} ako je to unaprijed unos."
+apps/erpnext/erpnext/stock/utils.py +217,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 +126,Litre,Litre
+apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Litre
 DocType: Task,Total Costing Amount (via Time Sheet),Ukupno Costing Iznos (preko Time Sheet)
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.py +63,Please setup Students under Student Groups,Molimo da podesite studente pod studentskim grupama
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Molimo da podesite studente pod studentskim grupama
 DocType: Item Website Specification,Item Website Specification,Specifikacija web stranice artikla
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +477,Leave Blocked,Ostavite blokirani
-apps/erpnext/erpnext/stock/doctype/item/item.py +723,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 +88,Bank Entries,banka unosi
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +119,Annual,godišnji
+apps/erpnext/erpnext/stock/doctype/item/item.py +709,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 +99,Bank Entries,banka unosi
+DocType: Crop,Annual,godišnji
 DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Pomirenje Item
 DocType: Stock Entry,Sales Invoice No,Faktura prodaje br
 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 +189,People who teach at your organisation,Ljudi koji predaju u vašoj organizaciji
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +131,Software Developer,Software Developer
+apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,Ljudi koji predaju u vašoj organizaciji
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Software Developer
 DocType: Item,Minimum Order Qty,Minimalna količina za naručiti
 DocType: Pricing Rule,Supplier Type,Dobavljač Tip
 DocType: Course Scheduling Tool,Course Start Date,Naravno Ozljede Datum
@@ -369,58 +388,64 @@
 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 +743,Item {0} is cancelled,Artikal {0} je otkazan
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +923,Material Request,Materijal zahtjev
+apps/erpnext/erpnext/stock/doctype/item/item.py +729,Item {0} is cancelled,Artikal {0} je otkazan
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Material Request,Materijal zahtjev
 DocType: Bank Reconciliation,Update Clearance Date,Ažurirajte provjeri datum
 DocType: Item,Purchase Details,Kupnja Detalji
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,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: Patient Relation,Relation,Odnos
-DocType: Shipping Rule,Worldwide Shipping,Dostavom diljem svijeta
-DocType: Patient Relation,Mother,majka
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +382,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
 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/schools/doctype/fees/fees.py +80,Payment request {0} created,Zahtev za plaćanje {0} kreiran
-apps/erpnext/erpnext/healthcare/setup.py +254,Low Sensitivity,Niska osetljivost
+apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Zahtev za plaćanje {0} kreiran
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Otvori naloge
+apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Niska osetljivost
 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 +276,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/accounts/doctype/journal_entry/journal_entry.py +274,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}
 DocType: Supplier,Address HTML,Adressa u HTML-u
 DocType: Lead,Mobile No.,Mobitel broj
 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 +146,Please select Charge Type first,Odaberite Naknada za prvi
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +163,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 +41,Latest,Najnovije
+DocType: Asset Maintenance Task,2 Yearly,2 Yearly
+DocType: Education Settings,Education Settings,Obrazovne postavke
 DocType: Vehicle Service,Inspection,inspekcija
 DocType: Supplier Scorecard Scoring Standing,Max Grade,Max Grade
 DocType: Email Digest,New Quotations,Nove ponude
 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: Employee,The first Leave Approver in the list will be set as the default Leave Approver,Prvi dopust Odobritelj na popisu će se postaviti kao zadani Odobritelj dopust
 DocType: Tax Rule,Shipping County,Dostava županije
-apps/erpnext/erpnext/config/desktop.py +159,Learn,Učiti
+apps/erpnext/erpnext/config/desktop.py +167,Learn,Učiti
 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 +663,Supplier Invoice No exists in Purchase Invoice {0},Dobavljač Račun ne postoji u fakturi {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +667,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: Vehicle,Fleet Manager,Fleet Manager
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +517,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} ne može biti negativan za stavku {2}
+DocType: Driver,Fleet Manager,Fleet Manager
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} ne može biti negativan za stavku {2}
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Pogrešna lozinka
 DocType: Item,Variant Of,Varijanta
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +367,Completed Qty can not be greater than 'Qty to Manufacture',Završene Qty ne može biti veća od 'Količina za proizvodnju'
+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
 DocType: Physician,Time per Appointment,Vreme po imenovanju
 apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Kružna Reference Error
 DocType: Appointment Type,Is Inpatient,Je stacionarno
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Guardian1 ime
+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})
@@ -429,20 +454,22 @@
 DocType: BOM Item,Rate & Amount,Stopa i količina
 apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Ovo se zasniva na transakcijama protiv ove kompanije. Pogledajte detalje u nastavku
 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 +258,Resistant,Otporno
+apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Otporno
 DocType: Journal Entry,Multi Currency,Multi valuta
-DocType: Payment Reconciliation Invoice,Invoice Type,Tip fakture
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +865,Delivery Note,Otpremnica
+DocType: Opening Invoice Creation Tool,Invoice Type,Tip fakture
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +933,Delivery Note,Otpremnica
 DocType: Consultation,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 +131,Cost of Sold Asset,Troškovi prodate imovine
-apps/erpnext/erpnext/accounts/utils.py +345,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.
-apps/erpnext/erpnext/stock/doctype/item/item.py +448,{0} entered twice in Item Tax,{0}pritisnite dva puta u sifri poreza
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Troškovi prodate imovine
+DocType: Volunteer,Morning,Jutro
+apps/erpnext/erpnext/accounts/utils.py +347,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.
+apps/erpnext/erpnext/stock/doctype/item/item.py +464,{0} entered twice in Item Tax,{0}pritisnite dva puta u sifri poreza
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,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 +81,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 +85,Please select month and year,Molimo odaberite mjesec i godinu
 DocType: Employee,Company Email,Zvanični e-mail
 DocType: GL Entry,Debit Amount in Account Currency,Debit Iznos u računu valuta
@@ -451,33 +478,35 @@
 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 +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"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
-apps/erpnext/erpnext/config/hr.py +238,"Employee designation (e.g. CEO, Director etc.).","Zvanje zaposlenog ( npr. CEO , direktor i sl. ) ."
+apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Zvanje zaposlenog ( npr. CEO , direktor i sl. ) ."
 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 +558,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: fakturi ne može se protiv postojeće imovine {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +602,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: fakturi ne može se protiv postojeće imovine {1}
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Hitno] Greška prilikom kreiranja ponavljajućeg% s za% s
+DocType: Land Unit,LInked Analysis,LInked Analysis
 DocType: Item Tax,Tax Rate,Porezna stopa
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} već izdvojeno za zaposlenog {1} {2} za razdoblje do {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +890,Select Item,Odaberite Item
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +915,Select Item,Odaberite Item
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +140,Purchase Invoice {0} is already submitted,Kupnja Račun {0} već je podnijela
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Row # {0}: serijski br mora biti isti kao {1} {2}
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Pretvoriti u non-Group
-apps/erpnext/erpnext/config/stock.py +127,Batch (lot) of an Item.,Serija (puno) proizvoda.
 DocType: C-Form Invoice Detail,Invoice Date,Datum fakture
 DocType: GL Entry,Debit Amount,Debit Iznos
-apps/erpnext/erpnext/accounts/party.py +253,There can only be 1 Account per Company in {0} {1},Tu može biti samo 1 račun po kompanije u {0} {1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +407,Please see attachment,Pogledajte prilog
+apps/erpnext/erpnext/accounts/party.py +251,There can only be 1 Account per Company in {0} {1},Tu može biti samo 1 račun po kompanije u {0} {1}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,Pogledajte prilog
 DocType: Purchase Order,% Received,% Primljeno
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Napravi studentske grupe
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +21,Setup Already Complete!!,Podešavanja je već okončano!!
+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 +24,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: Maintenance Visit,Maintenance Type,Održavanje Tip
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} nije upisanim na predmetu {2}
+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/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/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
 apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Dodaj Predmeti
@@ -488,31 +517,33 @@
 DocType: Packed Item,Packed Item,Dostava Napomena Pakiranje artikla
 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/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Obavezna polja - Get Učenici iz
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +14,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: Asset,Item Name,Naziv artikla
+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 +1508,Create a new Customer,Kreiranje novog potrošača
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1523,Create a new Customer,Kreiranje novog potrošača
 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
-DocType: Course Scheduling Tool,Rechedule,Rechedule
+DocType: Scheduling Tool,Rechedule,Rechedule
 DocType: Landed Cost Item,Applicable Charges,Mjerodavno Optužbe
 DocType: Workstation,Consumable Cost,potrošni cost
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',{0} ({1}) mora imati ulogu 'Leave Approver'
 DocType: Purchase Receipt,Vehicle Date,Vozilo Datum
 DocType: Student Log,Medical,liječnički
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Razlog za gubljenje
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +41,Lead Owner cannot be same as the Lead,Olovo Vlasnik ne može biti isti kao olovo
-apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not greater than unadjusted amount,Dodijeljeni iznos ne može veći od neprilagođena iznosa
+apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Ažurirajte broj računa
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Olovo Vlasnik ne može biti isti kao olovo
+apps/erpnext/erpnext/accounts/utils.py +353,Allocated amount can not greater than unadjusted amount,Dodijeljeni iznos ne može veći od neprilagođena iznosa
 DocType: Announcement,Receiver,prijemnik
 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 +32,Opportunities,Prilike
@@ -528,7 +559,7 @@
 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 +209,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učionice / laboratorije, itd, gdje se mogu zakazati predavanja."
+apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učionice / laboratorije, itd, gdje se mogu zakazati predavanja."
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Unesite ime tvrtke prvi
 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
@@ -536,40 +567,45 @@
 DocType: Email Digest,Pending Purchase Orders,U očekivanju Narudžbenice
 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: 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'
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +142,Non Profit,Neprofitne
+DocType: Chapter,Non Profit,Neprofitne
 DocType: Production Order,Not Started,Nije počela
 DocType: Lead,Channel Partner,Partner iz prodajnog kanala
 DocType: Account,Old Parent,Stari Roditelj
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Obavezna polja - akademska godina
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Obavezna polja - akademska godina
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{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/hr/doctype/expense_claim/expense_claim.py +157,Please set default payable account for the company {0},Molimo postavite zadani plaća račun za kompaniju {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +182,Please set default payable account for the company {0},Molimo postavite zadani plaća račun za kompaniju {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 +685,Attribute {0} selected multiple times in Attributes Table,Atribut {0} odabrani više puta u atributi tabeli
+apps/erpnext/erpnext/stock/doctype/item/item.py +671,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
 apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Majstor za odmor .
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +77,Opening Invoice Item,Otvaranje stavke fakture
 DocType: Request for Quotation Item,Required Date,Potrebna Datum
 DocType: Delivery Note,Billing Address,Adresa za naplatu
 DocType: BOM,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: Driver,DRIVER-.#####,DRIVER -. #####
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Ukupno Qty
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Email ID
+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: Process Payroll,Select Payroll Period,Odaberite perioda isplate
+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 +29,Securities and Deposits,Vrijednosni papiri i depoziti
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +44,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Ne možete promijeniti način vrednovanja, jer postoje transakcije protiv nekih stvari koje nemaju svoj vlastiti način vrednovanja"
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Ne možete promijeniti način vrednovanja, jer postoje transakcije protiv nekih stvari koje nemaju svoj vlastiti način vrednovanja"
 apps/erpnext/erpnext/config/healthcare.py +133,Test Sample Master.,Testiraj Sample Master.
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Ukupno lišće dodijeljena je obavezno
 DocType: Patient,AB Positive,AB Pozitivan
@@ -591,35 +627,39 @@
 DocType: Training Event,Workshop,radionica
 DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Upozoravajte narudžbenice
 apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Navedite nekoliko svojih kupaca. Oni mogu biti tvrtke ili fizičke osobe.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Dobavljač&gt; Tip dobavljača
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +21,Enough Parts to Build,Dosta dijelova za izgradnju
 DocType: POS Profile User,POS Profile User,POS korisnik profila
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Direktni prihodi
 DocType: Patient Appointment,Date TIme,Date TIme
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"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/install_fixtures.py +126,Administrative Officer,Administrativni službenik
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +22,Please select Course,Molimo odaberite predmeta
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,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 +342,Please select Company,Molimo odaberite Company
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +350,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 +433,Please enter Warehouse for which Material Request will be raised,Unesite skladište za koje Materijal Zahtjev će biti podignuta
 DocType: Production Order,Additional Operating Cost,Dodatni operativnih troškova
 DocType: Lab Test Template,Lab Routine,Lab Routine
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,kozmetika
-apps/erpnext/erpnext/stock/doctype/item/item.py +545,"To merge, following properties must be same for both items","Spojiti , ova svojstva moraju biti isti za obje stavke"
+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 +526,"To merge, following properties must be same for both items","Spojiti , ova svojstva moraju biti isti za obje stavke"
 DocType: Shipping Rule,Net Weight,Neto težina
 DocType: Employee,Emergency Phone,Hitna Telefon
 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 +159,Student Application,Aplikacija za studente
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Molimo vas da definirati razred za Threshold 0%
+apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Aplikacija za studente
+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: Sales Order,To Deliver,Dostaviti
 DocType: Purchase Invoice Item,Item,Artikl
-apps/erpnext/erpnext/healthcare/setup.py +255,High Sensitivity,Visoka osetljivost
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2493,Serial no item cannot be a fraction,Serijski br stavka ne može biti frakcija
+apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Visoka osetljivost
+apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Volonterski podaci o tipu.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2512,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: Account,Profit and Loss,Račun dobiti i gubitka
 DocType: Patient,Risk Factors,Faktori rizika
@@ -628,6 +668,7 @@
 apps/erpnext/erpnext/config/stock.py +330,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
+DocType: Detected Disease,Disease,Bolest
 apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Definišite tip projekta.
 DocType: Supplier Scorecard,Weighting Function,Funkcija ponderiranja
 DocType: Physician,OP Consulting Charge,OP Konsalting Charge
@@ -636,27 +677,29 @@
 apps/erpnext/erpnext/setup/doctype/company/company.py +62,Account {0} does not belong to company: {1},Konto {0} ne pripada preduzeću {1}
 apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Skraćenica već koristi za druge kompanije
 DocType: Selling Settings,Default Customer Group,Zadana grupa korisnika
+DocType: Asset Repair,ARLOG-,ARLOG-
 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: Sales Order Item,Gross Profit,Bruto dobit
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Prirast ne može biti 0
 DocType: Production Planning Tool,Material Requirement,Materijal Zahtjev
 DocType: Company,Delete Company Transactions,Izbrišite Company Transakcije
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +350,Reference No and Reference Date is mandatory for Bank transaction,Poziv na broj i referentni datum je obavezan za transakcije banke
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,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
 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žete izbrisati serijski broj {0}, koji se koristi u prodaji transakcije"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Cr),Zatvaranje (Cr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +253,Closing (Cr),Zatvaranje (Cr)
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,zdravo
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +110,Move Item,Move Stavka
 DocType: Serial No,Warranty Period (Days),Jamstveni period (dani)
 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 +372,{0} {1} is not active,{0} {1} nije aktivan
-apps/erpnext/erpnext/config/accounts.py +285,Setup cheque dimensions for printing,dimenzije ček setup za štampanje
+apps/erpnext/erpnext/accounts/party.py +384,{0} {1} is not active,{0} {1} nije aktivan
+apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,dimenzije ček setup za štampanje
 DocType: Salary Slip,Salary Slip Timesheet,Plaća Slip Timesheet
 apps/erpnext/erpnext/controllers/buying_controller.py +157,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavljač skladišta obvezan je za sub - ugovoreni kupiti primitka
 DocType: Pricing Rule,Valid From,Vrijedi od
@@ -664,19 +707,21 @@
 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
-apps/erpnext/erpnext/stock/doctype/item/item.py +142,Valuation Rate is mandatory if Opening Stock entered,Vrednovanje Rate je obavezno ako ušla Otvaranje Stock
+apps/erpnext/erpnext/stock/doctype/item/item.py +144,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 +142,No records found in the Invoice table,Nisu pronađeni u tablici fakturu
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,Molimo najprije odaberite Društva i Party Tip
-apps/erpnext/erpnext/config/accounts.py +301,Financial / accounting year.,Financijska / obračunska godina .
+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 +293,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 +162,"Sorry, Serial Nos cannot be merged","Žao nam je , Serial Nos ne mogu spojiti"
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +63,Territory is Required in POS Profile,Teritorija je potrebna u POS profilu
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +68,Territory is Required in POS Profile,Teritorija je potrebna u POS profilu
 DocType: Supplier,Prevent RFQs,Sprečite RFQs
 apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Provjerite prodajnog naloga
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,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
 ,Lead Id,Lead id
 DocType: C-Form Invoice Detail,Grand Total,Ukupno za platiti
-DocType: Training Event,Course,Kurs
+DocType: Assessment Plan,Course,Kurs
 DocType: Timesheet,Payslip,payslip
 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
@@ -689,7 +734,9 @@
 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/stock/doctype/delivery_note/delivery_note.js +804,Sales Return,Povrat robe
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Kreiraj varijantu
+DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otvaranje alata za kreiranje fakture
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +851,Sales Return,Povrat robe
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Napomena: Ukupna izdvojena lišće {0} ne smije biti manja od već odobrenih lišće {1} za period
 ,Total Stock Summary,Ukupno Stock Pregled
 DocType: Announcement,Posted By,Postavljeno od
@@ -700,40 +747,45 @@
 apps/erpnext/erpnext/config/selling.py +28,Customer database.,Šifarnik kupaca
 DocType: Quotation,Quotation To,Ponuda za
 DocType: Lead,Middle Income,Srednji Prihodi
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Cr),P.S. (Pot)
-apps/erpnext/erpnext/stock/doctype/item/item.py +849,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"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 +349,Allocated amount can not be negative,Dodijeljeni iznos ne može biti negativan
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +225,Opening (Cr),P.S. (Pot)
+apps/erpnext/erpnext/stock/doctype/item/item.py +835,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"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 +351,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: 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.
 DocType: Repayment Schedule,Principal Amount,iznos glavnice
 DocType: Employee Loan Application,Total Payable Interest,Ukupno plaćaju interesa
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +59,Total Outstanding: {0},Ukupno izvanredan: {0}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,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 +118,Reference No & Reference Date is required for {0},Reference Nema & Reference Datum je potrebno za {0}
-DocType: Process Payroll,Select Payment Account to make Bank Entry,Izaberite plaćanje računa da banke Entry
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,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
 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/config/healthcare.py +118,Prescription Period,Period receptora
 DocType: Restaurant Reservation,Restaurant Reservation,Rezervacija restorana
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +186,Proposal Writing,Pisanje prijedlog
+DocType: Land Unit,Land Unit Name,Naziv jedinice zemljišta
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,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 +35,Notify Customers via Email,Obaveštavajte kupce putem e-pošte
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,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: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Ako je označeno, sirovine za predmete koji su pod ugovorom će biti uključeni u Industrijska Zahtjevi"
 apps/erpnext/erpnext/config/healthcare.py +61,Masters,Majstori
 DocType: Assessment Plan,Maximum Assessment Score,Maksimalan rezultat procjene
-apps/erpnext/erpnext/config/accounts.py +146,Update Bank Transaction Dates,Update Bank Transakcijski Termini
+apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Update Bank Transakcijski Termini
 apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Time Tracking
 DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICATE ZA TRANSPORTER
+apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,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: Timesheet,Billed,Naplaćeno
 DocType: Batch,Batch Description,Batch Opis
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Stvaranje grupa studenata
-apps/erpnext/erpnext/accounts/utils.py +721,"Payment Gateway Account not created, please create one manually.","Payment Gateway računa kreiranu, molimo vas da napravite ručno."
+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 +724,"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/schools/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
+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: Employee,Organization Profile,Profil organizacije
 DocType: Vital Signs,Height (In Meter),Visina (u metrima)
@@ -741,25 +793,25 @@
 DocType: Vehicle Service,Vehicle Service,Servis vozila
 apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Automatski aktivira zahtjev povratne informacije na osnovu uslova.
 DocType: Employee,Reason for Resignation,Razlog za ostavku
-apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Predložak za ocjene rada .
+apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Predložak za ocjene rada .
 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 +83,{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/accounts/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Asset {0} ne pripada kompaniji {1}
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,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 +36,"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."
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Neto promjena u zalihama
-apps/erpnext/erpnext/config/hr.py +157,Employee Loan Management,Zaposlenik kredit za upravljanje
+apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Zaposlenik kredit za upravljanje
 DocType: Employee,Passport Number,Putovnica Broj
-apps/erpnext/erpnext/schools/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/install_fixtures.py +120,Manager,menadžer
+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 +124,Manager,menadžer
 DocType: Payment Entry,Payment From / To,Plaćanje Od / Do
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +127,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Novi kreditni limit je manje od trenutne preostali iznos za kupca. Kreditni limit mora biti atleast {0}
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +155,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Novi kreditni limit je manje od trenutne preostali iznos za kupca. Kreditni limit mora biti atleast {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: Installation Note,IN-,IN-
@@ -768,43 +820,46 @@
 DocType: Lab Test Template,Compound,Jedinjenje
 DocType: Student Batch Name,Batch Name,Batch ime
 DocType: Fee Validity,Max number of visit,Maksimalan broj poseta
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +319,Timesheet created:,Timesheet created:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +908,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/schools/doctype/student_applicant/student_applicant.js +24,Enroll,upisati
+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 +920,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
 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 +56,Convert to Group,Pretvori u Grupi
+DocType: Delivery Trip,TOUR-.#####,TOUR -. #####
 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 +47,Delivered Amount,Isporučena Iznos
-DocType: Supplier,Fixed Days,Fiksni Dani
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests,Laboratorijske testove
+DocType: Company,Fixed Days,Fiksni Dani
 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.
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,objavljivanje
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,objavljivanje
 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 +157,{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 +227,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/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Posjeta za odrzavanje {0} mora biti otkazana prije otkazivanja ove ponude
+DocType: Asset Maintenance Log,AML-,AML-
 DocType: Item,Material Transfer,Materijal transfera
 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 +211,Opening (Dr),P.S. (Dug)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Dr),P.S. (Dug)
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Objavljivanje timestamp mora biti poslije {0}
 apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Da se ponavljaju dokumenti
 ,GST Itemised Purchase Register,PDV Specificirane Kupovina Registracija
+DocType: Course Scheduling Tool,Reschedule,Ponovo raspored
 DocType: Employee Loan,Total Interest Payable,Ukupno kamata
 DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Sleteo Troškovi poreza i naknada
 DocType: Production Order Operation,Actual Start Time,Stvarni Start Time
 DocType: BOM Operation,Operation Time,Operacija Time
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +293,Finish,završiti
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +395,Base,baza
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +315,Finish,završiti
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,baza
 DocType: Timesheet,Total Billed Hours,Ukupno Fakturisana Hours
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1351,Write Off Amount,Napišite paušalni iznos
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1438,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
@@ -818,33 +873,38 @@
 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: Interest,Interest,interes
+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: Purchase Receipt,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/install_fixtures.py +105,Marketing,marketing
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,marketing
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,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 +545,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 +377,Preview Salary Slip,Preview Plaća Slip
+apps/erpnext/erpnext/controllers/accounts_controller.py +589,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 +394,Preview Salary Slip,Preview Plaća Slip
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,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 +23,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: Land Unit,Longitude,Dužina
 ,Absent Student Report,Odsutan Student Report
+DocType: Crop,Crop Spacing UOM,Crop Spacing UOM
 DocType: Email Digest,Next email will be sent on:,Sljedeća e-mail će biti poslan na:
 DocType: Offer Letter Term,Offer Letter Term,Ponuda Pismo Term
 DocType: Supplier Scorecard,Per Week,Po tjednu
-apps/erpnext/erpnext/stock/doctype/item/item.py +658,Item has variants.,Stavka ima varijante.
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Total Student
+apps/erpnext/erpnext/stock/doctype/item/item.py +639,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/schools/doctype/fee_schedule/fee_schedule.js +41,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,"Evidencije o naknadi će biti stvorene u pozadini. U slučaju bilo kakve greške, poruka o grešci će se ažurirati u Rasporedu."
-apps/erpnext/erpnext/accounts/doctype/account/account.py +26,Company {0} does not exist,Kompanija {0} ne postoji
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,"Evidencije o naknadi će biti stvorene u pozadini. U slučaju bilo kakve greške, poruka o grešci će se ažurirati u Rasporedu."
+apps/erpnext/erpnext/accounts/doctype/account/account.py +241,Company {0} does not exist,Kompanija {0} ne postoji
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} ima važeću tarifu do {1}
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Tip stabla
 DocType: BOM Explosion Item,Qty Consumed Per Unit,Kol Potrošeno po jedinici
@@ -852,42 +912,46 @@
 DocType: Material Request Item,Quantity and Warehouse,Količina i skladišta
 DocType: Hub Settings,Unregister,Odjavite se
 DocType: Sales Invoice,Commission Rate (%),Komisija stopa (%)
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +24,Please select Program,Molimo odaberite program
+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: Purchase Order,Link to material requests,Link za materijal zahtjeva
 DocType: Hub Settings,Publish,Objavite
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Zračno-kosmički prostor
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Zračno-kosmički prostor
 DocType: Journal Entry,Credit Card Entry,Credit Card Entry
 apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Company i računi
 apps/erpnext/erpnext/config/healthcare.py +108,Appointment Type Master,Imenovanje tipa Master
-apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Roba dobijena od dobavljača.
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +58,In Value,u vrijednost
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,u vrijednost
 DocType: Lead,Campaign Name,Naziv kampanje
 DocType: Selling Settings,Close Opportunity After Days,Zatvori Opportunity Nakon nekoliko dana
 ,Reserved,Rezervirano
+DocType: Driver,License Details,Detalji o licenci
 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 +94,{0} is not a stock Item,{0} ne postoji na zalihama.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,{0} is not a stock Item,{0} ne postoji na zalihama.
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"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 +262,Please select Sample Retention Warehouse in Stock Settings first,Prvo izaberite skladište za zadržavanje uzorka u postavkama zaliha
 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/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Odaberite tjednik off dan
 DocType: Patient,O Negative,O Negativ
 DocType: Production 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 +96,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/accounts/doctype/account/account.py +95,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: Budget,Budget Against,budžet protiv
 DocType: Employee,Cell Number,Mobitel Broj
-apps/erpnext/erpnext/stock/reorder_item.py +177,Auto Material Requests Generated,Auto materijala Zahtjevi Generirano
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Za određene kriterijume nema zaposlenika. Proverite da li su listovi plata još uvek nisu kreirani.
+apps/erpnext/erpnext/stock/reorder_item.py +190,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 +152,You can not enter current voucher in 'Against Journal Entry' column,Ne možete ući trenutni voucher u 'Protiv Journal Entry' koloni
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +150,You can not enter current voucher in 'Against Journal Entry' column,Ne možete ući trenutni voucher u 'Protiv Journal Entry' koloni
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Rezervirano za proizvodnju
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,energija
+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/config/hr.py +98,Monthly salary statement.,Mjesečna plaća izjava.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +876,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/accounts/doctype/sales_invoice/sales_invoice.py +881,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
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} je nevažeća adresa e-pošte u &#39;Primaocima&#39;
@@ -895,12 +959,14 @@
 apps/erpnext/erpnext/config/healthcare.py +143,Antibiotic.,Antibiotik.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Od {0} {1} tipa
 DocType: Warranty Claim,CI-,CI-
-apps/erpnext/erpnext/controllers/buying_controller.py +291,Row {0}: Conversion Factor is mandatory,Red {0}: pretvorbe Factor je obvezno
-DocType: Employee,A+,A +
+apps/erpnext/erpnext/controllers/buying_controller.py +292,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 +326,"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}"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +501,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
-DocType: Opportunity,Maintenance,Održavanje
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +504,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
+DocType: Asset,Maintenance,Održavanje
 DocType: Item Attribute Value,Item Attribute Value,Stavka vrijednost atributa
+DocType: Item,Maximum sample quantity that can be retained,Maksimalna količina uzorka koja se može zadržati
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +393,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},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.
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,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.
@@ -950,21 +1016,25 @@
 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/physician_schedule/physician_schedule.js +26,Add Timeslots,Dodaj Timeslots
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset odbačen preko Journal Entry {0}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset odbačen preko Journal Entry {0}
 DocType: Employee Loan,Interest Income Account,Prihod od kamata računa
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Biotehnologija
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Poslato
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Biotehnologija
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Troškovi održavanja ureda
 apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Idi
 apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Postavljanje e-pošte
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,Unesite predmeta prvi
+DocType: Asset Repair,Downtime,Zaustavljanje
 DocType: Account,Liability,Odgovornost
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,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/hr/doctype/expense_claim/expense_claim.py +234,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}.
 DocType: Salary Detail,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/get_item_details.py +319,Price List not selected,Popis Cijena ne bira
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +964,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 +362,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 +216,Warning: Invalid Attachment {0},Upozorenje: Invalid Prilog {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +218,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 +764,No Permission,Bez dozvole
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +438,Quote Requested,Citiraj zatraženo
 DocType: Vital Signs,Heart Rate / Pulse,Srčana brzina / impuls
@@ -972,32 +1042,34 @@
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +50,"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 +48,'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 +125,Nos,Nos
+apps/erpnext/erpnext/utilities/user_progress.py +143,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/patient/patient_dashboard.py +14,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 +549,Row #{0}: Asset {1} must be submitted,Row # {0}: Asset {1} moraju biti dostavljeni
+apps/erpnext/erpnext/controllers/accounts_controller.py +593,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: Subscription,Stopped,Zaustavljen
 DocType: Item,If subcontracted to a vendor,Ako podizvođača na dobavljača
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +111,Student Group is already updated.,Student Grupa je već ažurirana.
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Student Grupa je već ažurirana.
 DocType: SMS Center,All Customer Contact,Svi kontakti kupaca
-apps/erpnext/erpnext/config/stock.py +158,Upload stock balance via csv.,Prenesi dionica ravnotežu putem CSV.
-DocType: Warehouse,Tree Details,Tree Detalji
+DocType: Land Unit,Tree Details,Tree Detalji
 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 +352,"If you have any questions, please get back to us.","Ako imate bilo kakvih pitanja, molimo Vas da se vratimo na nas."
 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 +111,{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 +89,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 +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Račun {2} ne može biti Group
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Stavka Row {idx}: {doctype} {docname} ne postoji u gore &#39;{doctype}&#39; sto
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +289,Timesheet {0} is already completed or cancelled,Timesheet {0} je već završen ili otkazan
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +291,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
 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 +49,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 +343,C-Form records,C - Form zapisi
+apps/erpnext/erpnext/config/accounts.py +335,C-Form records,C - Form zapisi
 apps/erpnext/erpnext/config/selling.py +311,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 +354,Thank you for your business!,Hvala vam za vaše poslovanje!
@@ -1008,43 +1080,48 @@
 DocType: HR Settings,Retirement Age,Retirement Godine
 DocType: Bin,Moving Average Rate,Premještanje prosječna stopa
 DocType: Production Planning Tool,Select Items,Odaberite artikle
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} protiv placanje {1}  od {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +370,{0} against Bill {1} dated {2},{0} protiv placanje {1}  od {2}
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Setup Institution
 DocType: Program Enrollment,Vehicle/Bus Number,Vozila / Autobus broj
-apps/erpnext/erpnext/schools/doctype/course/course.js +17,Course Schedule,Raspored za golf
+apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Raspored za golf
 DocType: Request for Quotation Supplier,Quote Status,Quote Status
 DocType: Maintenance Visit,Completion Status,Završetak Status
 DocType: HR Settings,Enter retirement age in years,Unesite dob za odlazak u penziju u godinama
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +252,Target Warehouse,Ciljana galerija
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +118,Please select a warehouse,Molimo odaberite skladište
+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 +128,Please select a warehouse,Molimo odaberite skladište
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Molimo da podesite serije brojeva za prisustvo preko Setup&gt; Serija numeracije
 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: Stock Entry,STE-,ste-
 DocType: Upload Attendance,Import Attendance,Uvoz posjećenost
 apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Sve grupe artikala
-DocType: Process Payroll,Activity Log,Dnevnik aktivnosti
 apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Neto dobit / gubitak
 apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Automatski nova poruka na podnošenje transakcija .
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,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: Production 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
-apps/erpnext/erpnext/stock/doctype/item/item.js +363,Item Variant {0} already exists with same attributes,Stavka Variant {0} već postoji s istim atributima
+apps/erpnext/erpnext/stock/doctype/item/item.js +489,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 +115,'Opening',&#39;Otvaranje&#39;
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Open To Do
 DocType: Notification Control,Delivery Note Message,Otpremnica - poruka
 DocType: Lab Test Template,Result Format,Format rezultata
 DocType: Expense Claim,Expenses,troškovi
+DocType: Delivery Stop,Delivery Notes,Napomene o isporuci
 DocType: Item Variant Attribute,Item Variant Attribute,Stavka Variant Atributi
 ,Purchase Receipt Trends,Račun kupnje trendovi
-DocType: Process Payroll,Bimonthly,časopis koji izlazi svaka dva mjeseca
+DocType: Payroll Entry,Bimonthly,časopis koji izlazi svaka dva mjeseca
 DocType: Vehicle Service,Brake Pad,Brake Pad
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +115,Research & Development,Istraživanje i razvoj
+DocType: Fertilizer,Fertilizer Contents,Sadržaj đubriva
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,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
@@ -1056,16 +1133,18 @@
 DocType: Sales Team,Incentives,Poticaji
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +64,Register for Hub,Registrujte se za Hub
 DocType: SMS Log,Requested Numbers,Traženi brojevi
+DocType: Volunteer,Evening,Veče
 DocType: Production Planning Tool,Only Obtain Raw Materials,Nabavite samo sirovine
-apps/erpnext/erpnext/config/hr.py +142,Performance appraisal.,Ocjenjivanje.
+DocType: Customer,Bypass credit limit check at Sales Order,Provjerite kreditni limit za obilaznicu na nalogu za prodaju
+apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Ocjenjivanje.
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","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"
-apps/erpnext/erpnext/controllers/accounts_controller.py +347,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Plaćanje Entry {0} je povezan protiv Order {1}, proverite da li treba da se povuče kao napredak u ovom računu."
+apps/erpnext/erpnext/controllers/accounts_controller.py +391,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Plaćanje Entry {0} je povezan protiv Order {1}, proverite da li treba da se povuče kao napredak u ovom računu."
 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 +321,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 +119,"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 """
+apps/erpnext/erpnext/accounts/doctype/account/account.py +118,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","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: Hub Settings,Publish Pricing,Objavite Pricing
 DocType: Notification Control,Expense Claim Rejected Message,Rashodi Zahtjev odbijen poruku
@@ -1074,12 +1153,15 @@
 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: Delivery Trip,Delivery Stops,Dostava je prestala
 DocType: Salary Slip,Working Days,Radnih dana
 DocType: Serial No,Incoming Rate,Dolazni Stopa
 DocType: Packing Slip,Gross Weight,Bruto težina
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Omogući Hub
-apps/erpnext/erpnext/public/js/setup_wizard.js +107,The name of your company for which you are setting up this system.,Ime vaše tvrtke za koje ste postavljanje ovog sustava .
+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 +108,Setup your Institute in ERPNext,Postavite svoj institut u ERPNext
+DocType: Agriculture Analysis Criteria,Plant Analysis,Analiza biljaka
 DocType: Job Applicant,Hold,Zadrži
 DocType: Employee,Date of Joining,Datum pristupa
 DocType: Naming Series,Update Series,Update serija
@@ -1087,27 +1169,31 @@
 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 +817,Purchase Receipt,Račun kupnje
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +843,Purchase Receipt,Račun kupnje
 ,Received Items To Be Billed,Primljeni Proizvodi se naplaćuje
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +173,Submitted Salary Slips,Postavio Plaća Slips
-apps/erpnext/erpnext/config/accounts.py +311,Currency exchange rate master.,Majstor valute .
+apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Majstor valute .
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +198,Reference Doctype must be one of {0},Referentni Doctype mora biti jedan od {0}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +302,Unable to find Time Slot in the next {0} days for Operation {1},U nemogućnosti da pronađe termin u narednih {0} dana za operaciju {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},U nemogućnosti da pronađe termin u narednih {0} dana za operaciju {1}
 DocType: Production 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 +581,BOM {0} must be active,BOM {0} mora biti aktivna
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +585,BOM {0} must be active,BOM {0} mora biti aktivna
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +221,Closing (Opening + Total),Zatvaranje (otvaranje + ukupno)
 DocType: Journal Entry,Depreciation Entry,Amortizacija Entry
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,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: Crop Cycle,ISO 8016 standard,ISO 8016 standard
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,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
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Skladišta sa postojećim transakcija se ne može pretvoriti u knjizi.
 DocType: Bank Reconciliation,Total Amount,Ukupan iznos
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +32,Internet Publishing,Internet izdavaštvo
+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: Production Planning Tool,Production Orders,Nalozi
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +62,Balance Value,Vrijednost bilance
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,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 +72,Balance Value,Vrijednost bilance
 DocType: Lab Test,Lab Technician,Laboratorijski tehničar
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Sales Cjenovnik
 DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
@@ -1119,31 +1205,33 @@
 DocType: Supplier,Default Payable Accounts,Uobičajeno Računi dobavljača
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Radnik {0} nije aktivan ili ne postoji
 DocType: Fee Structure,Components,komponente
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +251,Please enter Asset Category in Item {0},Molimo vas da unesete imovine Kategorija tačke {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +653,Item Variants {0} updated,Stavka Varijante {0} ažurirani
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +272,Please enter Asset Category in Item {0},Molimo vas da unesete imovine Kategorija tačke {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +634,Item Variants {0} updated,Stavka Varijante {0} ažurirani
 DocType: Quality Inspection Reading,Reading 6,Čitanje 6
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
 of this","da se generiše. Ako je odloženo, morate ručno promijeniti polje &quot;Ponovi na dan dana&quot; ovoga"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +919,Cannot {0} {1} {2} without any negative outstanding invoice,Ne mogu {0} {1} {2} bez ikakvih negativnih izuzetan fakture
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,Ne mogu {0} {1} {2} bez ikakvih negativnih izuzetan fakture
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Narudzbine avans
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,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 +254,Define budget for a financial year.,Definirajte budžet za finansijsku godinu.
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +197,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 +246,Define budget for a financial year.,Definirajte budžet za finansijsku godinu.
 DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Zadana banka / novčani račun će se automatski ažurirati prema POS računu, kada je ovaj mod odabran."
 DocType: Lead,LEAD-,vo |
 DocType: Employee,Permanent Address Is,Stalna adresa je
 DocType: Production Order Operation,Operation completed for how many finished goods?,Operacija završena za koliko gotovih proizvoda?
-apps/erpnext/erpnext/public/js/setup_wizard.js +47,The Brand,The Brand
+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,Exit Interview Details,Izlaz Intervju Detalji
 DocType: Item,Is Purchase Item,Je dobavljivi proizvod
-DocType: Asset,Purchase Invoice,Narudzbine
+DocType: Journal Entry Account,Purchase Invoice,Narudzbine
 DocType: Stock Ledger Entry,Voucher Detail No,Bon Detalj Ne
-apps/erpnext/erpnext/accounts/page/pos/pos.js +765,New Sales Invoice,Prodaja novih Račun
+apps/erpnext/erpnext/accounts/page/pos/pos.js +780,New Sales Invoice,Prodaja novih Račun
 DocType: Stock Entry,Total Outgoing Value,Ukupna vrijednost Odlazni
 DocType: Physician,Appointments,Imenovanja
 apps/erpnext/erpnext/public/js/account_tree_grid.js +224,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
-apps/erpnext/erpnext/accounts/page/pos/pos.js +778,Sync Offline Invoices,Sync Offline Fakture
+DocType: Sales Invoice Item,Rate With Margin (Company Currency),Rate With Margin (Valuta kompanije)
+apps/erpnext/erpnext/accounts/page/pos/pos.js +793,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.
@@ -1153,13 +1241,14 @@
 DocType: Guardian,Guardian Name,Guardian ime
 DocType: Cheque Print Template,Has Print Format,Ima Print Format
 DocType: Employee Loan,Sanctioned,sankcionisani
-apps/erpnext/erpnext/accounts/page/pos/pos.js +73, is mandatory. Maybe Currency Exchange record is not created for ,Obavezan unos. Možda nije kreirana valuta za
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +112,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Navedite rednim brojem predmeta za {1}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +622,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","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: Job Opening,Publish on website,Objaviti na web stranici
-apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Isporuke kupcima.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +641,Supplier Invoice Date cannot be greater than Posting Date,Dobavljač Datum računa ne može biti veći od Datum knjiženja
+apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,Obavezan unos. Možda nije kreirana valuta za
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Navedite rednim brojem predmeta za {1}
+DocType: Crop Cycle,Crop Cycle,Crop Cycle
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +632,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","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: Student Admission,Publish on website,Objaviti na web stranici
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +645,Supplier Invoice Date cannot be greater than Posting Date,Dobavljač Datum računa ne može biti veći od Datum knjiženja
 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 +132,Indirect Income,Neizravni dohodak
 DocType: Student Attendance Tool,Student Attendance Tool,Student Posjeta Tool
 DocType: Restaurant Menu,Price List (Auto created),Cenovnik (Automatski kreiran)
@@ -1167,55 +1256,60 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Varijacija
 ,Company Name,Naziv preduzeća
 DocType: SMS Center,Total Message(s),Ukupno poruka ( i)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +888,Select Item for Transfer,Izaberite Stavka za transfer
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +913,Select Item for Transfer,Izaberite Stavka za transfer
 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/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 +132,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/industry_type.py +16,Chemical,Hemijski
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,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.
 DocType: BOM,Raw Material Cost(Company Currency),Sirovina troškova (poduzeća Valuta)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +732,All items have already been transferred for this Production Order.,Svi predmeti su već prebačen za ovu proizvodnju Order.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +758,All items have already been transferred for this Production Order.,Svi predmeti su već prebačen za ovu proizvodnju Order.
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,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 +126,Meter,metar
+apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,metar
 DocType: Workstation,Electricity Cost,Troškovi struje
 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/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Sačuvaj postavke
+DocType: Delivery Stop,Notified by Email,Prijavljen putem e-pošte
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +683,Requested Products,Traženi proizvodi
 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 +48,Upload your letter head and logo. (you can edit them later).,Unos glavu pismo i logo. (Možete ih kasnije uređivanje).
+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/accounts/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Sljedeća Amortizacija datum se unosi kao proteklih dana
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +204,White,Bijel
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Sljedeća Amortizacija datum se unosi kao proteklih dana
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Bijel
 DocType: SMS Center,All Lead (Open),Svi potencijalni kupci (aktualni)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +231,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Red {0}: Količina nije dostupan za {4} u skladištu {1} na postavljanje trenutku stupanja ({2} {3})
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +248,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Red {0}: Količina nije dostupan za {4} u skladištu {1} na postavljanje trenutku stupanja ({2} {3})
 DocType: Purchase Invoice,Get Advances Paid,Kreiraj avansno plaćanje
 DocType: Item,Automatically Create New Batch,Automatski Create New Batch
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Make ,Napraviti
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Make ,Napraviti
 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 +158,Order Type must be one of {0},Tip narudžbe mora biti jedan od {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +126,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 +468,Please enter Account for Change Amount,Unesite račun za promjene Iznos
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +472,Please enter Account for Change Amount,Unesite račun za promjene Iznos
 DocType: Student Batch Name,Student Batch Name,Student Batch Ime
 DocType: Consultation,Doctor,Doktor
 DocType: Holiday List,Holiday List Name,Naziv liste odmora
 DocType: Repayment Schedule,Balance Loan Amount,Balance Iznos kredita
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.js +13,Schedule Course,Raspored predmeta
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +224,Stock Options,Stock Opcije
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Raspored predmeta
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Stock Options,Stock Opcije
 DocType: Journal Entry Account,Expense Claim,Rashodi polaganja
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +234,Do you really want to restore this scrapped asset?,Da li zaista želite da vratite ovaj ukinut imovine?
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +358,Qty for {0},Količina za {0}
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +254,Do you really want to restore this scrapped asset?,Da li zaista želite da vratite ovaj ukinut imovine?
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +380,Qty for {0},Količina za {0}
 DocType: Leave Application,Leave Application,Ostavite aplikaciju
 DocType: Patient,Patient Relation,Relacija pacijenta
 apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Ostavite raspodjele alat
@@ -1231,18 +1325,22 @@
 apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Navedite {0}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,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.py +682,Attribute table is mandatory,Atribut sto je obavezno
+apps/erpnext/erpnext/stock/doctype/item/item.js +384,Variant creation has been queued.,Kreiranje varijante je stavljeno u red.
+apps/erpnext/erpnext/stock/doctype/item/item.py +668,Attribute table is mandatory,Atribut sto je obavezno
 DocType: Production Planning Tool,Get Sales Orders,Kreiraj narudžbe
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} ne može biti negativna
 DocType: Training Event,Self-Study,Samo-studiranje
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +480,Discount,Popust
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +537,Discount,Popust
+DocType: Membership,Membership,Članstvo
 DocType: Asset,Total Number of Depreciations,Ukupan broj Amortizacija
 DocType: Sales Invoice Item,Rate With Margin,Stopu sa margina
 DocType: Workstation,Wages,Plata
-DocType: Task,Urgent,Hitan
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +157,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
+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 +174,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 +664,Please select a field to edit from numpad,Molimo izaberite polje za uređivanje iz numpad-a
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +723,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 +253,Cannot be a fixed asset item as Stock Ledger is created.,Ne može biti osnovna stavka sredstva kao što je stvorena knjiga zaliha.
 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
 DocType: Item,Manufacturer,Proizvođač
 DocType: Landed Cost Item,Purchase Receipt Item,Kupnja Potvrda predmet
@@ -1251,12 +1349,11 @@
 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 +72,Selling Amount,Prodaja Iznos
 DocType: Repayment Schedule,Interest Amount,Iznos kamata
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +109,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Vi steRashodi Odobritelj za ovaj rekord . Molimo Ažuriranje "" status"" i Save"
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +120,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Vi steRashodi Odobritelj za ovaj rekord . Molimo Ažuriranje "" status"" i Save"
 DocType: Serial No,Creation Document No,Stvaranje dokumenata nema
 DocType: Issue,Issue,Tiketi
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Zapisi
 DocType: Asset,Scrapped,odbačen
-apps/erpnext/erpnext/config/stock.py +200,"Attributes for Item Variants. e.g Size, Color etc.","Osobine Stavka Varijante. npr veličina, boja i sl"
 DocType: Purchase Invoice,Returns,povraćaj
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,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}
@@ -1265,7 +1362,8 @@
 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
-DocType: Employee,A-,A-
+DocType: Delivery Trip,Delivery Trip,Dostava putovanja
+DocType: Student,A-,A-
 DocType: Production Planning Tool,Include non-stock items,Uključuju ne-stanju proizvodi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Prodajni troškovi
 DocType: Consultation,Diagnosis,Dijagnoza
@@ -1273,8 +1371,8 @@
 DocType: GL Entry,Against,Protiv
 DocType: Item,Default Selling Cost Center,Zadani trošak prodaje
 DocType: Sales Partner,Implementation Partner,Provedba partner
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1598,ZIP Code,Poštanski broj
-apps/erpnext/erpnext/controllers/selling_controller.py +271,Sales Order {0} is {1},Prodajnog naloga {0} je {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1613,ZIP Code,Poštanski broj
+apps/erpnext/erpnext/controllers/selling_controller.py +245,Sales Order {0} is {1},Prodajnog naloga {0} je {1}
 DocType: Opportunity,Contact Info,Kontakt Informacije
 apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Izrada Stock unosi
 DocType: Packing Slip,Net Weight UOM,Težina mjerna jedinica
@@ -1286,18 +1384,21 @@
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Datum završetka ne može biti manja od početnog datuma
 DocType: Sales Person,Select company name first.,Prvo odaberite naziv preduzeća.
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +181,Low to High,Niska do visoka
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +202,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 +24,To {0} | {1} {2},Za {0} | {1} {2}
+DocType: Delivery Trip,Driver Name,Ime vozača
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Prosječna starost
-DocType: School Settings,Attendance Freeze Date,Posjećenost Freeze Datum
-apps/erpnext/erpnext/utilities/user_progress.py +89,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.
+DocType: Education Settings,Attendance Freeze Date,Posjećenost Freeze Datum
+apps/erpnext/erpnext/utilities/user_progress.py +107,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 +31,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 +57,All BOMs,Svi sastavnica
 DocType: Patient,Default Currency,Zadana valuta
 DocType: Expense Claim,From Employee,Od zaposlenika
-apps/erpnext/erpnext/controllers/accounts_controller.py +407,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: Driver,Cellphone Number,Broj mobitela
+apps/erpnext/erpnext/controllers/accounts_controller.py +451,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: Upload Attendance,Attendance From Date,Gledatelja Od datuma
 DocType: Appraisal Template Goal,Key Performance Area,Područje djelovanja
@@ -1306,20 +1407,22 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +229,{0} {1} must be submitted,{0} {1} mora biti podnesen
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +151,Quantity must be less than or equal to {0},Količina mora biti manji ili jednak {0}
 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 +161,Please select BOM in BOM field for Item {0},Molimo odaberite BOM BOM u polje za Stavka {0}
 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
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Doprinos%
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +212,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Prema Kupnja Postavke ako Narudžbenice željeni == &#39;DA&#39;, onda za stvaranje fakturi, korisnik treba prvo stvoriti Narudžbenice za stavku {0}"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Prema Kupnja Postavke ako Narudžbenice željeni == &#39;DA&#39;, onda za stvaranje fakturi, korisnik treba prvo stvoriti Narudžbenice za stavku {0}"
 DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Tvrtka registracijski brojevi za svoju referencu. Porezni brojevi itd.
 DocType: Sales Partner,Distributor,Distributer
 DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Košarica Shipping pravilo
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +233,Production Order {0} must be cancelled before cancelling this Sales Order,Proizvodnja Red {0} mora biti otkazana prije poništenja ovu prodajnog naloga
-apps/erpnext/erpnext/public/js/controllers/transaction.js +68,Please set 'Apply Additional Discount On',Molimo podesite &#39;primijeniti dodatne popusta na&#39;
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Production Order {0} must be cancelled before cancelling this Sales Order,Proizvodnja Red {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Molimo podesite &#39;primijeniti dodatne popusta na&#39;
 ,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 +215,Project Collaboration Invitation,Projekt Collaboration Poziv
+apps/erpnext/erpnext/projects/doctype/project/project.py +226,Project Collaboration Invitation,Projekt Collaboration Poziv
 DocType: Salary Slip,Deductions,Odbici
 DocType: Leave Allocation,LAL/,LAL /
 DocType: Setup Progress Action,Action Name,Naziv akcije
@@ -1327,49 +1430,51 @@
 apps/erpnext/erpnext/regional/india/utils.py +24,First 2 digits of GSTIN should match with State number {0},Prva 2 cifre GSTIN treba se podudarati s državnim broj {0}
 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
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,Capacity Planning Error,Kapaciteta za planiranje Error
+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
 DocType: Salary Slip,Earnings,Zarada
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +391,Finished Item {0} must be entered for Manufacture type entry,Završio Stavka {0} mora biti unesen za tip Proizvodnja unos
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +416,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 +550,Nothing to request,Ništa se zatražiti
+apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Izaberite svoje domene
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Još jedan budžet rekord &#39;{0}&#39; već postoji protiv {1} &#39;{2}&#39; za fiskalnu godinu {3}
+DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Polja će se kopirati samo u trenutku kreiranja.
 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/install_fixtures.py +113,Management,upravljanje
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,upravljanje
 DocType: Cheque Print Template,Payer Settings,Payer Postavke
 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: Purchase Invoice,Is Return,Je li povratak
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +80,Caution,Oprez
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +787,Return / Debit Note,Povratak / Debit Napomena
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,Caution,Oprez
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,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 +205,{0} valid serial nos for Item {1},{0} valjani serijski broj za artikal {1}
+apps/erpnext/erpnext/stock/utils.py +210,{0} valid serial nos for Item {1},{0} valjani serijski broj za artikal {1}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Kod artikla ne može se mijenjati za serijski broj.
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +26,POS Profile {0} already created for user: {1} and company {2},POS profil {0} već kreirali za korisnika: {1} {2} i kompanija
-DocType: Sales Invoice Item,UOM Conversion Factor,UOM konverzijski faktor
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +23,Please enter Item Code to get Batch Number,Unesite Šifra da Batch Broj
+DocType: Purchase Invoice Item,UOM Conversion Factor,UOM konverzijski faktor
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Unesite Šifra da Batch Broj
 DocType: Stock Settings,Default Item Group,Zadana grupa proizvoda
 DocType: Employee Loan,Partially Disbursed,djelomično Isplaćeno
+apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Grant informacije.
 apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Šifarnik dobavljača
 DocType: Account,Balance Sheet,Završni račun
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +701,Cost Center For Item with Item Code ',Troška Za Stavke sa Šifra '
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +748,Cost Center For Item with Item Code ',Troška Za Stavke sa Šifra '
 DocType: Fee Validity,Valid Till,Valid Till
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2454,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",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/accounts/page/pos/pos.js +2473,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",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 +28,"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"
+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
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,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/stock/doctype/batch/batch.js +90,Stock Entry {0} created,Stock Entry {0} stvorio
-apps/erpnext/erpnext/controllers/buying_controller.py +297,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/batch/batch.js +97,Stock Entry {0} created,Stock Entry {0} stvorio
+apps/erpnext/erpnext/controllers/buying_controller.py +298,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Odbijena Količina ne može unijeti u Kupovina Povratak
 ,Purchase Order Items To Be Billed,Narudžbenica Proizvodi se naplaćuje
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Updating estimated arrival times.,Ažuriranje procijenjenih vremena dolaska.
 DocType: Purchase Invoice Item,Net Rate,Neto stopa
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +151,Please select a customer,Izaberite kupca
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +147,Please select a customer,Izaberite kupca
 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
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Stavku 1
@@ -1382,28 +1487,31 @@
 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 Order,Group same items,Grupa iste stavke
-DocType: Global Defaults,Disable Rounded Total,Ugasiti zaokruženi iznos
+DocType: Purchase Invoice,Disable Rounded Total,Ugasiti zaokruženi iznos
 DocType: Employee Loan Application,Repayment Info,otplata Info
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,' Prijave ' ne može biti prazno
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +446,'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 +81,Duplicate row {0} with same {1},Dupli red {0} sa istim {1}
 ,Trial Balance,Pretresno bilanca
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +449,Fiscal Year {0} not found,Fiskalna godina {0} nije pronađen
-apps/erpnext/erpnext/config/hr.py +300,Setting up Employees,Postavljanje Zaposlenih
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Fiskalna godina {0} nije pronađen
+apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Postavljanje Zaposlenih
 DocType: Sales Order,SO-,SO-
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,Odaberite prefiks prvi
-DocType: Employee,O-,O-
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +185,Research,istraživanje
+DocType: Student,O-,O-
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,istraživanje
 DocType: Maintenance Visit Purpose,Work Done,Rad Done
 apps/erpnext/erpnext/controllers/item_variant.py +33,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/accounts/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Stavka {0} mora biti ne-stock stavka
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,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
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Najstarije
-apps/erpnext/erpnext/stock/doctype/item/item.py +519,"An Item Group exists with same name, please change the item name or rename the item group","Stavka Grupa postoji s istim imenom , molimo promijenite ime stavku ili preimenovati stavku grupe"
-apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +367,Rest Of The World,Ostatak svijeta
+apps/erpnext/erpnext/stock/doctype/item/item.py +500,"An Item Group exists with same name, please change the item name or rename the item group","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 +105,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
@@ -1422,7 +1530,6 @@
 DocType: Student,STUD.,STUD.
 DocType: Production Order,Qty To Manufacture,Količina za proizvodnju
 DocType: Email Digest,New Income,novi prihod
-DocType: School Settings,School Settings,škola Postavke
 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
@@ -1434,26 +1541,27 @@
 DocType: Patient Appointment,More Info,Više informacija
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +178,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 +148,Example: Masters in Computer Science,Primer: Masters u Computer Science
+apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Primer: Masters u Computer Science
 DocType: Purchase Invoice,Rejected Warehouse,Odbijen galerija
 DocType: GL Entry,Against Voucher,Protiv Voucheru
 DocType: Item,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/accounts/page/pos/pos.js +74, to ,Za
+apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,Za
 DocType: Supplier Quotation Item,Lead Time in days,Potencijalni kupac u danima
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Računi se plaćaju Sažetak
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +337,Payment of salary from {0} to {1},Isplata plaće iz {0} do {1}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},Isplata plaće iz {0} do {1}
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,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 +70,Sales Order {0} is not valid,Prodajnog naloga {0} nije ispravan
+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/setup/doctype/company/company.py +218,"Sorry, companies cannot be merged","Žao nam je , tvrtke ne mogu spojiti"
+apps/erpnext/erpnext/setup/doctype/company/company.py +215,"Sorry, companies cannot be merged","Žao nam je , tvrtke ne mogu spojiti"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Testiranje laboratorijskih testova
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +162,"The total Issue / Transfer quantity {0} in Material Request {1}  \
 							cannot be greater than requested quantity {2} for Item {3}",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/install_fixtures.py +193,Small,Mali
-DocType: Employee,Employee Number,Broj radnika
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,Mali
+DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Stavka o otvaranju fakture kreiranja stavke
+DocType: Education Settings,Employee Number,Broj radnika
 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 )
@@ -1463,17 +1571,20 @@
 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
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +97,Contract,ugovor
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,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 +869,UOM coversion factor required for UOM: {0} in Item: {1},UOM faktor coversion potrebna za UOM: {0} u točki: {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +932,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 +92,Indirect Expenses,Neizravni troškovi
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Row {0}: Qty is mandatory,Red {0}: Količina je obvezno
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Poljoprivreda
-apps/erpnext/erpnext/accounts/page/pos/pos.js +770,Sync Master Data,Sync Master Data
-apps/erpnext/erpnext/utilities/user_progress.py +117,Your Products or Services,Vaši proizvodi ili usluge
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Row {0}: Qty is mandatory,Red {0}: Količina je obvezno
+DocType: Agriculture Analysis Criteria,Agriculture,Poljoprivreda
+apps/erpnext/erpnext/accounts/page/pos/pos.js +785,Sync Master Data,Sync Master Data
+DocType: Asset Repair,Repair Cost,Troškovi popravki
+apps/erpnext/erpnext/utilities/user_progress.py +135,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
 DocType: Special Test Items,Special Test Items,Specijalne testne jedinice
 DocType: Mode of Payment,Mode of Payment,Način plaćanja
-apps/erpnext/erpnext/stock/doctype/item/item.py +190,Website Image should be a public file or website URL,Sajt slika treba da bude javni datoteke ili web stranice URL
+apps/erpnext/erpnext/stock/doctype/item/item.py +192,Website Image should be a public file or website URL,Sajt slika treba da bude javni datoteke ili web stranice URL
 DocType: Student Applicant,AP,AP
 DocType: Purchase Invoice Item,BOM,BOM
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,To jekorijen stavka grupa i ne može se mijenjati .
@@ -1481,49 +1592,52 @@
 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
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +415,"{0}: Employee email not found, hence email not sent",{0}: e-mail nije poslat jer e-mail zaposlenog nije pronađen
+DocType: Volunteer,Volunteer Name,Ime volontera
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent",{0}: e-mail nije poslat jer e-mail zaposlenog nije pronađen
+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/healthcare/doctype/patient_appointment/patient_appointment.js +67,Please select Physician and Date,Izaberite lekar i datum
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Izaberite lekar i datum
 DocType: Student Group Student,Group Roll Number,Grupa Roll Broj
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"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/projects/doctype/project/project.py +78,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Ukupno sve težine zadatka treba da bude 1. Molimo prilagodite težine svih zadataka projekta u skladu s tim
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +578,Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena
-apps/erpnext/erpnext/stock/get_item_details.py +151,Item {0} must be a Sub-contracted Item,Stavka {0} mora bitisklopljen ugovor artikla
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +143,"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/projects/doctype/project/project.py +80,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Ukupno sve težine zadatka treba da bude 1. Molimo prilagodite težine svih zadataka projekta u skladu s tim
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +582,Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena
+apps/erpnext/erpnext/stock/get_item_details.py +146,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 +43,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/production_order/production_order.js +223,Please set the Item Code first,Molimo prvo postavite kod za stavku
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +245,Please set the Item Code first,Molimo prvo postavite kod za stavku
 DocType: Item,ITEM-,Artikl-
-apps/erpnext/erpnext/controllers/selling_controller.py +151,Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100
+apps/erpnext/erpnext/controllers/selling_controller.py +119,Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100
 DocType: Sales Invoice Item,Edit Description,Uredi opis
 DocType: Antibiotic,Antibiotic,Antibiotik
 ,Team Updates,Team Updates
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +885,For Supplier,za Supplier
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +910,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/schools/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Kreirana naknada
+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}
 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 +47,"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 """
+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: Authorization Rule,Transaction,Transakcija
 DocType: Patient Appointment,Duration,Trajanje
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,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/stock/doctype/warehouse/warehouse.py +54,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)
-apps/erpnext/erpnext/stock/utils.py +200,Serial number {0} entered more than once,Serijski broj {0} ušao više puta
-DocType: Depreciation Schedule,Journal Entry,Časopis Stupanje
+apps/erpnext/erpnext/stock/utils.py +205,Serial number {0} entered more than once,Serijski broj {0} ušao više puta
+DocType: Journal Entry,Journal Entry,Časopis Stupanje
+DocType: Expense Claim Advance,Unclaimed amount,Neobjavljeni iznos
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{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/manufacturing/doctype/bom/bom.py +587,BOM {0} does not belong to Item {1},BOM {0} ne pripada Stavka {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +591,BOM {0} does not belong to Item {1},BOM {0} ne pripada Stavka {1}
 DocType: Sales Partner,Target Distribution,Ciljana Distribucija
 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
@@ -1538,11 +1652,11 @@
 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/install_fixtures.py +150,Hardware,Hardver
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Hardver
 DocType: Prescription Dosage,Prescription Dosage,Dosage na recept
 DocType: Attendance,HR Manager,Šef ljudskih resursa
-apps/erpnext/erpnext/accounts/party.py +177,Please select a Company,Molimo odaberite poduzeća
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Privilege Leave,Privilege dopust
+apps/erpnext/erpnext/accounts/party.py +178,Please select a Company,Molimo odaberite poduzeća
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Privilege dopust
 DocType: Purchase Invoice,Supplier Invoice Date,Dobavljač Datum fakture
 apps/erpnext/erpnext/templates/includes/product_page.js +18,per,po
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Trebate omogućiti Košarica
@@ -1554,7 +1668,7 @@
 ,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: Purchase Taxes and Charges,Add or Deduct,Zbrajanje ili oduzimanje
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +82,Overlapping conditions found between:,Preklapanje uvjeti nalaze između :
+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 +187,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 +328,Food,Hrana
@@ -1562,7 +1676,7 @@
 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/hub_node/page/hub/hub.js +118,Do you want to publish your Items to Hub ?,Da li želite objaviti svoje stavke u Hub?
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +36,Enrolling student,upisa student
+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
@@ -1574,7 +1688,7 @@
 DocType: Rename Tool,Utilities,Komunalne usluge
 DocType: POS Profile,Accounting,Računovodstvo
 DocType: Employee,EMP/,EMP /
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +123,Please select batches for batched item ,Molimo odaberite serija za dozirana stavku
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Molimo odaberite serija za dozirana stavku
 DocType: Asset,Depreciation Schedules,Amortizacija rasporedi
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Period aplikacija ne može biti razdoblje raspodjele izvan odsustva
 DocType: Activity Cost,Projects,Projekti
@@ -1587,7 +1701,7 @@
 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 """
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +66,Approval Status must be 'Approved' or 'Rejected',"Status Odobrenje mora biti ""Odobreno"" ili "" Odbijeno """
 DocType: Physician,Contacts and Address,Kontakti i adresa
 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"""
@@ -1595,14 +1709,15 @@
 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
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +212,Stock Entries already created for Production Order ,Stock unosi već stvorene za proizvodnju Order
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217,Stock Entries already created for Production Order ,Stock unosi već stvorene za proizvodnju Order
 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 +33,Net Change in Fixed Asset,Neto promjena u fiksnoj Asset
 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 +663,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/production_order/production_order.js +359,Max: {0},Max: {0}
+apps/erpnext/erpnext/controllers/accounts_controller.py +775,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Punjenje tipa ' Stvarni ' u redu {0} ne mogu biti uključeni u točki Rate
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Max: {0},Max: {0}
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Od datuma i vremena
 DocType: Email Digest,For Company,Za tvrtke
 apps/erpnext/erpnext/config/support.py +17,Communication log.,Dnevni pregled komunikacije
@@ -1611,18 +1726,19 @@
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +73,Buying Amount,Iznos nabavke
 DocType: Sales Invoice,Shipping Address Name,Dostava adresa Ime
 DocType: Material Request,Terms and Conditions Content,Uvjeti sadržaj
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +555,cannot be greater than 100,ne može biti veća od 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +734,Item {0} is not a stock Item,Stavka {0} nijestock Stavka
+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
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +580,cannot be greater than 100,ne može biti veća od 100
+apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item {0} is not a stock Item,Stavka {0} nijestock Stavka
 DocType: Maintenance Visit,Unscheduled,Neplanski
 DocType: Employee,Owned,U vlasništvu
 DocType: Salary Detail,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
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +115,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","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"
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","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: Vehicle,License Plate,registarska tablica
 DocType: Appraisal,Goals,Golovi
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +326,Select POS Profile,Izaberite POS profil
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +343,Select POS Profile,Izaberite POS profil
 DocType: Warranty Claim,Warranty / AMC Status,Jamstveni / AMC Status
 ,Accounts Browser,Šifrarnik konta
 DocType: Payment Entry Reference,Payment Entry Reference,Plaćanje Entry Reference
@@ -1631,25 +1747,28 @@
 ,Batch-Wise Balance History,Batch-Wise bilanca Povijest
 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/install_fixtures.py +101,Apprentice,šegrt
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,šegrt
 DocType: Purchase Invoice,Company GSTIN,kompanija GSTIN
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,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"
 DocType: Supplier Scorecard Period,SSC-,SSC-
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +154,Employee cannot report to himself.,Zaposleni ne može prijaviti samog sebe.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,Zaposleni ne može prijaviti samog sebe.
 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 +245,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}
+apps/erpnext/erpnext/accounts/party.py +243,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: 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 +191,Tax Rule for transactions.,Porez pravilo za transakcije.
+apps/erpnext/erpnext/config/accounts.py +183,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 +60,Show unclosed fiscal year's P&L balances,Pokaži Neriješeni fiskalnu godinu P &amp; L salda
 DocType: Lab Test Template,Collection Details,Detalji o kolekciji
+DocType: POS Profile,Allow Print Before Pay,Dozvoli štampanje pre plaćanja
+DocType: Land Unit,Linked Soil Texture,Linked Soil Texture
 DocType: Shipping Rule,Shipping Account,Konto transporta
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{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
@@ -1657,44 +1776,48 @@
 DocType: Stock Entry,Total Additional Costs,Ukupno dodatnih troškova
 DocType: Course Schedule,SH,SH
 DocType: BOM,Scrap Material Cost(Company Currency),Otpadnog materijala troškova (poduzeća Valuta)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Sub Assemblies,pod skupštine
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,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: Asset Movement,Stock Manager,Stock Manager
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +144,Source warehouse is mandatory for row {0},Izvor skladište je obvezno za redom {0}
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +809,Packing Slip,Odreskom
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +149,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 +856,Packing Slip,Odreskom
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,najam ureda
 apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Postavke Setup SMS gateway
+DocType: Disease,Common Name,Zajedničko ime
 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/install_fixtures.py +121,Analyst,analitičar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,analitičar
 DocType: Item,Inventory,Inventar
 DocType: Item,Sales Details,Prodajni detalji
 DocType: Quality Inspection,QI-,QI-
 DocType: Opportunity,With Items,Sa stavkama
+DocType: Asset Maintenance,Maintenance Team,Tim za održavanje
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,u kol
-DocType: School Settings,Validate Enrolled Course for Students in Student Group,Potvrditi upisala kurs za studente u Studentskom Group
+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/install_fixtures.py +143,Government,Vlada
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,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
-apps/erpnext/erpnext/public/js/setup_wizard.js +60,Institute Name,Institut ime
+apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Institut ime
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Unesite iznos otplate
 apps/erpnext/erpnext/config/stock.py +305,Item Variants,Stavka Varijante
-DocType: Company,Services,Usluge
+apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Usluge
 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 +1017,Select Possible Supplier,Odaberite Moguće dobavljač
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1039,Select Possible Supplier,Odaberite Moguće dobavljač
 DocType: Sales Invoice,Source,Izvor
 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 +248,Asset Category is mandatory for Fixed Asset item,Asset Kategorija je obavezno za Fixed stavku imovine
+apps/erpnext/erpnext/stock/doctype/item/item.py +250,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 +145,No records found in the Payment table,Nisu pronađeni u tablici plaćanja
-apps/erpnext/erpnext/schools/utils.py +19,This {0} conflicts with {1} for {2} {3},Ovo {0} sukobe sa {1} za {2} {3}
+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
@@ -1709,16 +1832,18 @@
 apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Taken
 DocType: Student,Date of Leaving,Datum odlaska
 DocType: Pricing Rule,For Price List,Za Cjeniku
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Executive Search
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Executive Search
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Podešavanje podrazumevanih vrednosti
 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 +331,POS Profile is required to use Point-of-Sale,POS profil je potreban za korištenje Point-of-Sale
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +451,POS Profile is required to use Point-of-Sale,POS profil je potreban za korištenje Point-of-Sale
 DocType: Purchase Invoice Item,Net Amount,Neto iznos
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +138,{0} {1} has not been submitted so the action cannot be completed,{0} {1} 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: 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
 apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Molimo stvoriti novi račun iz kontnog plana .
 ,Support Hour Distribution,Podrška Distribucija sata
 DocType: Maintenance Visit,Maintenance Visit,Posjeta za odrzavanje
@@ -1728,10 +1853,12 @@
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Update Print Format
 DocType: Landed Cost Voucher,Landed Cost Help,Sleteo Cost Pomoć
 DocType: Purchase Invoice,Select Shipping Address,Izaberite Dostava Adresa
+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/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Potraživanja Pregled
 DocType: Employee Loan,Monthly Repayment Amount,Mjesečna otplate Iznos
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +191,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
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Otvaranje faktura
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,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
 DocType: GST HSN Code,HSN Code,HSN Kod
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Doprinos Iznos
@@ -1739,25 +1866,25 @@
 DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,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.
 DocType: Expense Claim,EXP,EXP
-apps/erpnext/erpnext/config/stock.py +205,Brand master.,Šifarnik brendova
-apps/erpnext/erpnext/schools/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: 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: Healthcare Settings,Manage Sample Collection,Upravljanje sakupljanjem uzorka
 DocType: Program Enrollment Tool,Program Enrollments,program Upis
 DocType: Patient,Tobacco Past Use,Korišćenje prošlosti duvana
 DocType: Sales Invoice Item,Brand Name,Naziv brenda
 DocType: Purchase Receipt,Transporter Details,Transporter Detalji
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Korisnik {0} je već dodeljen lekaru {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2638,Default warehouse is required for selected item,Uobičajeno skladište je potreban za izabranu stavku
-apps/erpnext/erpnext/utilities/user_progress.py +125,Box,Kutija
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1014,Possible Supplier,moguće dobavljač
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2657,Default warehouse is required for selected item,Uobičajeno skladište je potreban za izabranu stavku
+apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Kutija
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1036,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 +29,Healthcare (beta),Zdravstvo (beta)
+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
 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/schools/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Duplikat broj roll za studentske {0}
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Duplikat broj roll za studentske {0}
 DocType: Budget,Action if Annual Budget Exceeded,Akcija ako Godišnji budžet Exceeded
 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
@@ -1772,50 +1899,55 @@
 DocType: C-Form,III,III
 apps/erpnext/erpnext/config/stock.py +310,Opening Stock Balance,Otvaranje Stock Balance
 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/stock/doctype/stock_entry/stock_entry.py +368,Not allowed to tranfer more {0} than {1} against Purchase Order {2},Nije dozvoljeno da se više tranfer {0} od {1} protiv narudžbenice {2}
 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 +555,Manufacturing Quantity is mandatory,Proizvodnja Količina je obvezno
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +581,Manufacturing Quantity is mandatory,Proizvodnja Količina je obvezno
 DocType: Employee 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/config/hr.py +127,Claims for company expense.,Potraživanja za tvrtke trošak.
+apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Potraživanja za tvrtke trošak.
 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/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,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
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,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 +145,Stock Liabilities,Stock Obveze
 DocType: Purchase Invoice,Supplier Warehouse,Dobavljač galerija
 DocType: Opportunity,Contact Mobile No,Kontak GSM
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +356,Select Company,Izaberite kompaniju
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +382,Select Company,Izaberite kompaniju
 ,Material Requests for which Supplier Quotations are not created,Materijalni Zahtjevi za koje Supplier Citati nisu stvorene
+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.
 DocType: Student Group,Set 0 for no limit,Set 0 za no limit
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +141,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Dan (e) na koje se prijavljujete za odmor su praznici. Vi ne trebate podnijeti zahtjev za dozvolu.
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Red {idx}: {polje} je potreban za kreiranje Opening {invoice_type} faktura
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Ponovo pošaljite mail plaćanja
 apps/erpnext/erpnext/templates/pages/projects.html +27,New task,novi zadatak
 DocType: Consultation,Appointment,Imenovanje
 apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Make ponudu
 apps/erpnext/erpnext/config/selling.py +216,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
-apps/erpnext/erpnext/stock/doctype/item/item.py +414,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/stock/doctype/item/item.py +430,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 +208,Leave of type {0} cannot be longer than {1},Ostavite tipa {0} ne može biti duži od {1}
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,Pokušajte planiraju operacije za X dana unaprijed.
 DocType: HR Settings,Stop Birthday Reminders,Zaustavi Rođendan Podsjetnici
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +250,Please set Default Payroll Payable Account in Company {0},Molimo podesite Uobičajeno plaće plaćaju račun poduzeća {0}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Molimo podesite Uobičajeno plaće plaćaju račun poduzeća {0}
 DocType: SMS Center,Receiver List,Lista primalaca
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1068,Search Item,Traži Stavka
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1083,Search Item,Traži Stavka
+DocType: Payment Schedule,Payment Amount,Plaćanje Iznos
 DocType: Patient Appointment,Referring Physician,Referentni lekar
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Consumed Iznos
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Neto promjena u gotovini
 DocType: Assessment Plan,Grading Scale,Pravilo Scale
-apps/erpnext/erpnext/stock/doctype/item/item.py +409,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 +612,Already completed,već završena
+apps/erpnext/erpnext/stock/doctype/item/item.py +425,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 +616,Already completed,već završena
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Stock u ruci
+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 +29,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: Physician,Hospital,Bolnica
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +362,Quantity must not be more than {0},Količina ne smije biti više od {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +384,Quantity must not be more than {0},Količina ne smije biti više od {0}
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Prethodne finansijske godine nije zatvoren
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Starost (dani)
 DocType: Quotation Item,Quotation Item,Artikl iz ponude
@@ -1825,14 +1957,15 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Serijski Ne {0} {1} količina ne može bitidio
 apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Dobavljač Vrsta majstor .
 DocType: Purchase Order Item,Supplier Part Number,Dobavljač Broj dijela
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +105,Conversion rate cannot be 0 or 1,Stopa pretvorbe ne može biti 0 ili 1
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Stopa pretvorbe ne može biti 0 ili 1
 DocType: Subscription,Reference Document,referentni dokument
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +208,{0} {1} is cancelled or stopped,{0} {1} je otkazan ili zaustavljen
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +209,{0} {1} is cancelled or stopped,{0} {1} je otkazan ili zaustavljen
 DocType: Accounts Settings,Credit Controller,Kreditne kontroler
+DocType: Grant Application,Applicant Type,Tip podnosioca zahteva
 DocType: Delivery Note,Vehicle Dispatch Date,Vozilo Dispatch Datum
 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 +234,Purchase Receipt {0} is not submitted,Račun kupnje {0} nije podnesen
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,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"
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% Fakturisana
@@ -1841,40 +1974,44 @@
 DocType: Party Account,Party Account,Party račun
 apps/erpnext/erpnext/config/setup.py +122,Human Resources,Ljudski resursi
 DocType: Lead,Upper Income,Viši Prihodi
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +41,Reject,odbiti
+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
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Make isplata Entry
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Red {0}: Advance protiv Dobavljač mora biti debitne
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Supplier must be debit,Red {0}: Advance protiv Dobavljač mora biti debitne
 DocType: Company,Default Values,Default vrijednosti
+DocType: Membership,INR,INR
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Frekvencija} Digest
 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/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Against Supplier Invoice {0} dated {1},Protiv Dobavljač fakture {0} od {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Protiv Dobavljač fakture {0} od {1}
 DocType: Customer,Default Price List,Zadani cjenik
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +244,Asset Movement record {0} created,rekord Asset pokret {0} stvorio
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +265,Asset Movement record {0} created,rekord Asset pokret {0} stvorio
 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
 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
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +183,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,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: Journal Entry,Entry Type,Entry Tip
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Nema plana procjene povezani sa ovom grupom procjena
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Nema plana procjene povezani sa ovom grupom procjena
 ,Customer Credit Balance,Customer Credit Balance
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Neto promjena na računima dobavljača
 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 +148,Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.
+apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,cijene
 DocType: Quotation,Term Details,Oročeni Detalji
-DocType: Project,Total Sales Cost (via Sales Order),Ukupna prodaja troškova (putem prodajnog naloga)
-apps/erpnext/erpnext/schools/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/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/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Lead Count
-apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} mora biti veći od 0
+apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} mora biti veći od 0
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +17,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 +64,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/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Obavezna polja - Program
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +16,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: Purchase Invoice,End date of current invoice's period,Kraj datum tekućeg razdoblja dostavnice
 DocType: Pricing Rule,Applicable For,primjenjivo za
@@ -1885,14 +2022,14 @@
 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: Maintenance Visit,Partially Completed,Djelomično Završeni
-apps/erpnext/erpnext/healthcare/setup.py +256,Moderate Sensitivity,Umerena osetljivost
+apps/erpnext/erpnext/healthcare/setup.py +257,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: Sales Invoice,Packed Items,Pakirano Predmeti
 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 +65,'Total',&#39;Ukupno&#39;
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +71,'Total',&#39;Ukupno&#39;
 DocType: Shopping Cart Settings,Enable Shopping Cart,Enable Košarica
 DocType: Employee,Permanent Address,Stalna adresa
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +258,"Advance paid against {0} {1} cannot be greater \
 						than Grand Total {2}",Unaprijed plaćeni protiv {0} {1} ne može biti veći \ od Grand Ukupno {2}
 DocType: Patient,Medication,Lijekovi
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Odaberite Šifra
@@ -1903,36 +2040,42 @@
 DocType: Purchase Invoice,Additional Discount,Dodatni popust
 DocType: Selling Settings,Selling Settings,Podešavanja prodaje
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Potvrdi akciju
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +39,Online Auctions,Online aukcije
+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 +98,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 +67,View in Cart,Pogledaj u košaricu
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Troškovi marketinga
 ,Item Shortage Report,Nedostatak izvješća za artikal
-apps/erpnext/erpnext/stock/doctype/item/item.js +279,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Težina se spominje, \n Navedite ""Težina UOM"" previše"
+apps/erpnext/erpnext/stock/doctype/item/item.js +275,"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
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Sljedeća Amortizacija Datum je obavezan za nove imovine
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Sljedeća Amortizacija Datum je obavezan za nove imovine
 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
+DocType: Customer,Primary Contact Detail,Primarna kontaktna detalja
 DocType: Drug Prescription,Dosage by time interval,Doziranje po vremenskom intervalu
 ,Student Fee Collection,Student Naknada Collection
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,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/accounts/doctype/purchase_invoice/purchase_invoice.py +160,Warehouse required at Row No {0},Skladište potrebno na red No {0}
-apps/erpnext/erpnext/public/js/setup_wizard.js +139,Please enter valid Financial Year Start and End Dates,Molimo vas da unesete važeću finansijsku godinu datume početka i završetka
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Skladište potrebno na red No {0}
+apps/erpnext/erpnext/public/js/setup_wizard.js +142,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
 DocType: Material Request,Transferred,prebačen
 DocType: Vehicle,Doors,vrata
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +196,ERPNext Setup Complete!,ERPNext Setup Complete!
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,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 +650,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: Packing Slip,PS-,PS-
+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.
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +118,A Customer Group exists with same name please change the Customer name or rename the Customer Group,Grupa kupaca sa istim nazivom već postoji. Promijenite naziv kupca ili promijenite naziv grupe kupaca.
+DocType: Payment Schedule,Payment Term,Rok plaćanja
+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,Grupa kupaca sa istim nazivom već postoji. Promijenite naziv kupca ili promijenite naziv grupe kupaca.
+DocType: Land Unit,Area,Područje
 apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Novi kontakt
 DocType: Territory,Parent Territory,Roditelj Regija
 DocType: Sales Invoice,Place of Supply,Mesto isporuke
@@ -1942,39 +2085,40 @@
 DocType: Announcement,Instructor,instruktor
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Izaberite stavku (opcionalno)
 DocType: Fee Schedule Student Group,Fee Schedule Student Group,Raspored studijske grupe
-DocType: Employee,AB+,AB +
+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
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +311,Quantity required for Item {0} in row {1},Količina potrebna za točke {0} je u redu {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +314,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 +46,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: Quotation,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 +36,Opening Balances,Početni balansi
 DocType: Asset,Depreciation Method,Način Amortizacija
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +67,Offline,Offline
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +64,Offline,Offline
 DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je li ovo pristojba uključena u osnovne stope?
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Ukupna ciljna
+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
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Nema Radni nalozi stvoreni
 DocType: Stock Reconciliation,Reconciliation JSON,Pomirenje JSON
 apps/erpnext/erpnext/accounts/report/financial_statements.html +3,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
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +141,Request for Quotation: {0},Zahtjev za ponudu: {0}
 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
-apps/erpnext/erpnext/schools/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 +197,Main,Glavni
-apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant,Varijanta
+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 +194,Main,Glavni
+apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Varijanta
 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 +428,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
+apps/erpnext/erpnext/stock/doctype/item/item.py +444,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 +1088,Make Purchase Order,Provjerite narudžbenice
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1137,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 +152,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
@@ -1982,36 +2126,38 @@
 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
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +177,Work-in-Progress Warehouse is required before Submit,Rad u tijeku Warehouse je potrebno prije Podnijeti
+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/config/hr.py +40,Applicant for a Job.,Podnositelj prijave za posao.
 DocType: Purchase Order Item,Warehouse and Reference,Skladište i upute
 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/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Student Group Strength
+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 +250,Against Journal Entry {0} does not have any unmatched {1} entry,Protiv Journal Entry {0} nema premca {1} unos
-apps/erpnext/erpnext/config/hr.py +137,Appraisals,Appraisals
+apps/erpnext/erpnext/config/hr.py +142,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 +205,Duplicate Serial No entered for Item {0},Dupli serijski broj je unešen za artikl {0}
 DocType: Shipping Rule Condition,A condition for a Shipping Rule,A uvjet za Shipping Pravilo
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +161,Please enter ,Molimo unesite
-apps/erpnext/erpnext/controllers/accounts_controller.py +423,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","ne može overbill za Stavka {0} u redu {1} više od {2}. Kako bi se omogućilo preko-računa, molimo vas da postavite u kupovini Postavke"
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +212,Please set filter based on Item or Warehouse,Molimo podesite filter na osnovu Item ili Skladište
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,Molimo unesite
+apps/erpnext/erpnext/controllers/accounts_controller.py +467,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","ne može overbill za Stavka {0} u redu {1} više od {2}. Kako bi se omogućilo preko-računa, molimo vas da postavite u kupovini Postavke"
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Dnevnik održavanja
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +234,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)
 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 +584,BOM {0} must be submitted,BOM {0} mora biti dostavljena
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +588,BOM {0} must be submitted,BOM {0} mora biti dostavljena
 DocType: Authorization Control,Authorization Control,Odobrenje kontrole
-apps/erpnext/erpnext/controllers/buying_controller.py +308,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 +782,Payment,Plaćanje
+apps/erpnext/erpnext/controllers/buying_controller.py +309,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 +808,Payment,Plaćanje
 apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","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: Production Order Operation,Actual Time and Cost,Stvarno vrijeme i troškovi
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +54,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materijal Zahtjev maksimalno {0} može biti za točku {1} od prodajnog naloga {2}
+DocType: Crop,Crop Spacing,Rastojanje usjeva
 DocType: Course,Course Abbreviation,Skraćenica za golf
 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/accounts/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Imovine ne može biti otkazan, jer je već {0}"
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +160,"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 +29,Employee {0} on Half day on {1},Zaposlenik {0} na Poludnevni na {1}
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,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
@@ -2021,9 +2167,9 @@
 DocType: Quality Inspection Reading,Reading 10,Čitanje 10
 DocType: Hub Category,Hub Node,Hub Node
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Unijeli duple stavke . Molimo ispraviti i pokušajte ponovno .
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +125,Associate,Pomoćnik
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Pomoćnik
 DocType: Asset Movement,Asset Movement,Asset pokret
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2165,New Cart,novi Košarica
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2180,New Cart,novi Košarica
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Stavka {0} nijeserijaliziranom predmeta
 DocType: SMS Center,Create Receiver List,Kreiraj listu primalaca
 DocType: Vehicle,Wheels,Wheels
@@ -2034,18 +2180,21 @@
 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/industry_type.py +52,Telecommunications,Telekomunikacije
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekomunikacije
+apps/erpnext/erpnext/accounts/party.py +266,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 +680,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 +36,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/templates/emails/recurring_document_failed.html +3,For,Za
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +150,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Može se odnositi red samo akotip zadužen je "" Na prethodni red Iznos 'ili' prethodnog retka Total '"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"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
-apps/erpnext/erpnext/config/accounts.py +249,Tree of financial Cost Centers.,Tree financijskih troškova centara.
+apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Tree financijskih troškova centara.
 DocType: Serial No,Delivery Document No,Dokument isporuke br
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +191,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}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,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/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Artikal {0} se pojavljuje više puta u cjeniku {1}
@@ -2058,19 +2207,20 @@
 apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Update Response
 apps/erpnext/erpnext/public/js/utils.js +226,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 +25,Batch ID is mandatory,Batch ID je obavezno
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +26,Batch ID is mandatory,Batch ID je obavezno
 DocType: Sales Person,Parent Sales Person,Roditelj Prodaja Osoba
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +180,High to Low,Visoka do niska
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +24,Select the program first,Prvo izaberite program
+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 +263,Managing Projects,Upravljanje projektima
 DocType: Supplier,Supplier of Goods or Services.,Dobavljač robe ili usluga.
 DocType: Budget,Fiscal Year,Fiskalna godina
+DocType: Asset Maintenance Log,Planned,Planirano
 DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,Podrazumevani računi potraživanja koji će se koristiti ako nisu postavljeni u Pacijentu da rezervišu Konsultacije.
 DocType: Vehicle Log,Fuel Price,Cena goriva
 DocType: Budget,Budget,Budžet
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +43,Set Open,Set Open
-apps/erpnext/erpnext/stock/doctype/item/item.py +245,Fixed Asset Item must be a non-stock item.,Osnovnih sredstava Stavka mora biti ne-stock stavku.
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Set Open
+apps/erpnext/erpnext/stock/doctype/item/item.py +247,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 +50,"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/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
@@ -2084,12 +2234,13 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,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
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +321,Same item has been entered multiple times. {0},Ista stavka je uneta više puta. {0}
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,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/manufacturing/doctype/bom/bom.py +324,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 +192,There were errors.,Bilo je grešaka .
 DocType: Guardian,Guardian Interests,Guardian Interesi
 DocType: Naming Series,Current Value,Trenutna vrijednost
-apps/erpnext/erpnext/controllers/accounts_controller.py +240,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: School Settings,Instructor Records to be created by,Instruktorske zapise koje kreira
+apps/erpnext/erpnext/controllers/accounts_controller.py +263,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: Delivery Note Item,Against Sales Order,Protiv prodajnog naloga
 ,Serial No Status,Serijski Bez Status
@@ -2101,19 +2252,20 @@
  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 +378,Amount {0} {1} deducted against {2},Broj {0} {1} oduzeti protiv {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Amount {0} {1} deducted against {2},Broj {0} {1} oduzeti protiv {2}
 DocType: Employee,Salary Information,Plaća informacije
 DocType: Sales Person,Name and Employee ID,Ime i ID zaposlenika
-apps/erpnext/erpnext/accounts/party.py +310,Due Date cannot be before Posting Date,Datum dospijeća ne može biti prije datuma objavljivanja
+apps/erpnext/erpnext/accounts/party.py +311,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/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Carine i porezi
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,Unesite Referentni datum
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,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: Purchase Order Item,Material Request Item,Materijal Zahtjev artikla
 apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Tree stavke skupina .
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +160,Cannot refer row number greater than or equal to current row number for this Charge type,Ne mogu se odnositi broj retka veći ili jednak trenutnom broju red za ovu vrstu Charge
+DocType: Payroll Entry,Get Employee Details,Dobijte podatke o zaposleniku
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,Cannot refer row number greater than or equal to current row number for this Charge type,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}"
@@ -2125,7 +2277,7 @@
 DocType: Sales Invoice,Accounting Details,Računovodstvo Detalji
 apps/erpnext/erpnext/setup/doctype/company/company.js +84,Delete all the Transactions for this Company,Izbrisati sve transakcije za ovu kompaniju
 DocType: Patient,O Positive,O Pozitivno
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +190,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: {1} Operacija nije završen za {2} Količina gotovih proizvoda u proizvodnji Order # {3}. Molimo vas da ažurirate rad status via Time Dnevnici
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +195,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: {1} Operacija nije završen za {2} Količina gotovih proizvoda u proizvodnji Order # {3}. Molimo vas da ažurirate rad status via Time Dnevnici
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investicije
 DocType: Issue,Resolution Details,Detalji o rjesenju problema
 apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,izdvajanja
@@ -2137,6 +2289,7 @@
 DocType: Employee 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/config/projects.py +31,Gantt chart of all tasks.,Gantogram svih zadataka.
@@ -2146,7 +2299,7 @@
 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
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Available slots,Raspoložive slotove
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,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 +350,Make Payment,izvrši plaćanje
 DocType: Room,Room Name,Soba Naziv
@@ -2157,15 +2310,18 @@
 ,Campaign Efficiency,kampanja efikasnost
 DocType: Discussion,Discussion,rasprava
 DocType: Payment Entry,Transaction ID,transakcija ID
+DocType: Volunteer,Anytime,Uvek
 DocType: Patient,Surgical History,Hirurška istorija
 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/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Molimo vas da postavite datum ulaska za zaposlenog {0}
 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
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +175,{0} ({1}) must have role 'Expense Approver',{0} ({1}) mora imati rolu 'odobravanje troskova'
-apps/erpnext/erpnext/utilities/user_progress.py +125,Pair,Par
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +912,Select BOM and Qty for Production,Odaberite BOM i količina za proizvodnju
+DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
+DocType: Chapter,Chapter,Poglavlje
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +200,{0} ({1}) must have role 'Expense Approver',{0} ({1}) mora imati rolu 'odobravanje troskova'
+apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Par
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +959,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
@@ -2173,37 +2329,41 @@
 DocType: Maintenance Schedule Detail,Actual Date,Stvarni datum
 DocType: Item,Has Batch No,Je Hrpa Ne
 apps/erpnext/erpnext/public/js/utils.js +100,Annual Billing: {0},Godišnji Billing: {0}
-apps/erpnext/erpnext/config/accounts.py +208,Goods and Services Tax (GST India),Poreska dobara i usluga (PDV Indija)
+apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Poreska dobara i usluga (PDV Indija)
 DocType: Delivery Note,Excise Page Number,Trošarina Broj stranice
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +157,"Company, From Date and To Date is mandatory","Kompanija, Od datuma i do danas je obavezno"
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +225,"Company, From Date and To Date is mandatory","Kompanija, Od datuma i do danas je obavezno"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Izlazite iz konsultacije
 DocType: Asset,Purchase Date,Datum kupovine
-DocType: Employee,Personal Details,Osobni podaci
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Molimo podesite &#39;Asset Amortizacija troškova Center&#39; u kompaniji {0}
+DocType: Volunteer,Volunteer Type,Volonterski tip
+DocType: Student,Personal Details,Osobni podaci
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,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)
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +373,Amount {0} {1} against {2} {3},Broj {0} {1} protiv {2} {3}
+DocType: Soil Texture,Soil Type,Vrsta zemljišta
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,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 +159,Item Group not mentioned in item master for item {0},Stavka artikla se ne spominje u master artiklu za artikal {0}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +358,Debit To account must be a Receivable account,Debit na račun mora biti potraživanja računa
-DocType: Shipping Rule Condition,Shipping Amount,Iznos transporta
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,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/utilities/user_progress.py +63,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: Purchase Invoice Item,Conversion Factor,Konverzijski faktor
+DocType: Purchase Order Item Supplied,Conversion Factor,Konverzijski faktor
 DocType: Purchase Order,Delivered,Isporučeno
 ,Vehicle Expenses,Troškovi vozila
 DocType: Serial No,Invoice Details,Račun Detalji
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},Očekivana vrijednost nakon koristan život mora biti veći ili jednak {0}
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +29,Start on,Počnite
+DocType: Grant Application,Show on Website,Show on Website
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},Očekivana vrijednost nakon koristan život mora biti veći ili jednak {0}
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Počnite
 DocType: Hub Category,Hub Category,Glavna kategorija
 DocType: Purchase Invoice,SEZ,SEZ
 DocType: Purchase Receipt,Vehicle Number,Broj vozila
 DocType: Employee Loan,Loan Amount,Iznos kredita
+apps/erpnext/erpnext/utilities/user_progress.py +88,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 +419,Row {0}: Bill of Materials not found for the Item {1},Red {0}: Bill materijala nije pronađen za stavku {1}
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +420,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 +98,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: Journal Entry,Accounts Receivable,Konto potraživanja
 ,Supplier-Wise Sales Analytics,Supplier -mudar prodaje Analytics
@@ -2214,28 +2374,29 @@
 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
-apps/erpnext/erpnext/hooks.py +140,Timesheets,Timesheets
+apps/erpnext/erpnext/hooks.py +144,Timesheets,Timesheets
 DocType: HR Settings,HR Settings,Podešavanja ljudskih resursa
 DocType: Salary Slip,net pay info,neto plata info
 DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Ova vrijednost se ažurira na listi podrazumevanih prodajnih cijena.
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +111,Expense Claim is pending approval. Only the Expense Approver can update status.,Rashodi Tužba se čeka odobrenje . SamoRashodi Odobritelj može ažurirati status .
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +122,Expense Claim is pending approval. Only the Expense Approver can update status.,Rashodi Tužba se čeka odobrenje . SamoRashodi Odobritelj može ažurirati status .
 DocType: Email Digest,New Expenses,novi Troškovi
 DocType: Purchase Invoice,Additional Discount Amount,Dodatni popust Iznos
 DocType: Consultation,Patient Details,Detalji pacijenta
 DocType: Patient,B Positive,B Pozitivan
-apps/erpnext/erpnext/controllers/accounts_controller.py +531,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Količina mora biti 1, kao stavka je osnovno sredstvo. Molimo koristite posebnom redu za više kom."
+apps/erpnext/erpnext/controllers/accounts_controller.py +575,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: 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 +291,Abbr can not be blank or space,Skraćeno ne može biti prazan ili prostora
+apps/erpnext/erpnext/setup/doctype/company/company.py +288,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 +62,Group to Non-Group,Grupa Non-grupa
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,sportovi
+apps/erpnext/erpnext/accounts/doctype/account/account.js +68,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 +56,Total Actual,Ukupno Actual
 DocType: Lab Test UOM,Test UOM,Test UOM
 DocType: Student Siblings,Student Siblings,student Siblings
-apps/erpnext/erpnext/utilities/user_progress.py +125,Unit,jedinica
-apps/erpnext/erpnext/stock/get_item_details.py +141,Please specify Company,Navedite tvrtke
+apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,jedinica
+apps/erpnext/erpnext/stock/get_item_details.py +136,Please specify Company,Navedite tvrtke
 ,Customer Acquisition and Loyalty,Stjecanje kupaca i lojalnost
+DocType: Asset Maintenance Task,Maintenance Task,Zadatak održavanja
 DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Skladište gdje ste održavanju zaliha odbijenih stavki
 DocType: Production Order,Skip Material Transfer,Preskočite Prijenos materijala
 apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nije moguće pronaći kurs za {0} do {1} za ključni datum {2}. Molimo vas da ručno stvoriti Mjenjačnica rekord
@@ -2245,70 +2406,73 @@
 DocType: Issue,Support,Podrška
 ,BOM Search,BOM pretraga
 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.
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +189,Closing (Opening + Totals),Zatvaranje (Otvaranje + Ukupno)
 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
 DocType: Email Digest,Pending Sales Orders,U očekivanju Prodajni nalozi
-apps/erpnext/erpnext/controllers/accounts_controller.py +279,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/controllers/accounts_controller.py +302,Account {0} is invalid. Account Currency must be {1},Račun {0} je nevažeća. Račun valuta mora biti {1}
 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 +1034,"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"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1060,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Referenca Vrsta dokumenta mora biti jedan od prodajnog naloga, prodaje fakture ili Journal Entry"
 DocType: Salary Component,Deduction,Odbitak
+DocType: Item,Retain Sample,Zadrži uzorak
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,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 +306,Item Price added for {0} in Price List {1},Stavka Cijena je dodao za {0} u {1} Cjenik
+apps/erpnext/erpnext/stock/get_item_details.py +349,Item Price added for {0} in Price List {1},Stavka Cijena je dodao za {0} u {1} Cjenik
 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/accounts/doctype/payment_entry/payment_entry.py +57,Difference Amount must be zero,Razlika iznos mora biti nula
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,U proizvodnji
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +59,Difference Amount must be zero,Razlika iznos mora biti nula
 DocType: Project,Gross Margin,Bruto marža
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,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/buying/doctype/supplier_quotation/supplier_quotation.js +764,Quotation,Ponude
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +957,Cannot set a received RFQ to No Quote,Ne možete postaviti primljeni RFQ na No Quote
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +913,Quotation,Ponude
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +982,Cannot set a received RFQ to No Quote,Ne možete postaviti primljeni RFQ na No Quote
 DocType: Quotation,QTN-,QTN-
 DocType: Salary Slip,Total Deduction,Ukupno Odbitak
 ,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 +201,Cost Updated,Troškova Ažurirano
-DocType: Employee,Date of Birth,Datum rođenja
+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
+DocType: Patient,Date of Birth,Datum rođenja
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,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: Patient,DOB,DOB
 DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Podešavanje Scorecard-a
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Naziv plana procene
-apps/erpnext/erpnext/stock/doctype/item/item.py +220,Warning: Invalid SSL certificate on attachment {0},Upozorenje: Invalid SSL certifikat o prilogu {0}
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Naziv plana procene
+apps/erpnext/erpnext/stock/doctype/item/item.py +222,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: Production 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/install_fixtures.py +226,Job Description,Opis posla
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Job Description,Opis posla
 DocType: Student Applicant,Applied,Applied
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +834,Re-open,Ponovno otvorena
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +859,Re-open,Ponovno otvorena
 DocType: Sales Invoice Item,Qty as per Stock UOM,Količina po burzi UOM
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 ime
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 ime
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"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."
 DocType: Expense Claim,Approver,Odobritelj
 ,SO Qty,SO Kol
 DocType: Guardian,Work Address,rad Adresa
 DocType: Appraisal,Calculate Total Score,Izračunaj ukupan rezultat
-DocType: Request for Quotation,Manufacturing Manager,Proizvodnja Manager
+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}
-apps/erpnext/erpnext/config/stock.py +163,Split Delivery Note into packages.,Split otpremnici u paketima.
-apps/erpnext/erpnext/hooks.py +107,Shipments,Pošiljke
+DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimalna dozvoljena vrijednost
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +42,User {0} already exists,Korisnik {0} već postoji
+apps/erpnext/erpnext/hooks.py +109,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 +227,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)
-DocType: Asset,Supplier,Dobavljači
+DocType: Pricing Rule,Supplier,Dobavljači
 DocType: Consultation,Consultation Time,Vrijeme konsultacije
 DocType: C-Form,Quarter,Četvrtina
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Razni troškovi
@@ -2321,112 +2485,120 @@
 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 +102,Item Variant Settings,Postavke varijante postavki
+apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Postavke varijante postavki
 apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,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/config/hr.py +223,"Types of employment (permanent, contract, intern etc.).","Vrste zapošljavanja ( trajni ugovor , pripravnik i sl. ) ."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +424,{0} is mandatory for Item {1},{0} je obavezno za tu stavku {1}
-DocType: Process Payroll,Fortnightly,četrnaestodnevni
+apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Vrste zapošljavanja ( trajni ugovor , pripravnik i sl. ) ."
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +428,{0} is mandatory for Item {1},{0} je obavezno za tu stavku {1}
+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/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"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 +125,Cost of New Purchase,Troškovi New Kupovina
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Troškovi New Kupovina
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,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: Payment Entry,Unallocated Amount,neraspoređenih Iznos
 apps/erpnext/erpnext/templates/includes/product_page.js +71,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/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Molimo da podesite sistem imenovanja zaposlenih u ljudskim resursima&gt; HR Settings
 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 +154,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"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Ne možete odabrati vrstu naboja kao ' na prethodnim Row Iznos ""ili"" u odnosu na prethodnu Row Ukupno ""za prvi red"
 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/industry_type.py +12,Banking,Bankarstvo
+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
 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"
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +56,There were errors while deleting following schedules:,"Bilo je grešaka, dok brisanja sljedeće raspored:"
 DocType: Bin,Ordered Quantity,Naručena količina
-apps/erpnext/erpnext/public/js/setup_wizard.js +115,"e.g. ""Build tools for builders""","na primjer "" Izgraditi alate za graditelje """
+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
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Računovodstvo Ulaz za {2} može se vršiti samo u valuti: {3}
-DocType: Production Order,In Process,U procesu
+DocType: Fee Schedule,In Process,U procesu
 DocType: Authorization Rule,Itemwise Discount,Itemwise Popust
 apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Tree financijskih računa.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} protiv naloga prodaje {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +362,{0} against Sales Order {1},{0} protiv naloga prodaje {1}
 DocType: Account,Fixed Asset,Dugotrajne imovine
 apps/erpnext/erpnext/config/stock.py +320,Serialized Inventory,Serijalizovanoj zaliha
 DocType: Employee 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/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} studentskih grupa stvorio.
+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/hr/doctype/daily_work_summary_settings/daily_work_summary_settings.py +17,There must be a default incoming Email Account enabled for this to work. Please setup a default incoming Email Account (POP/IMAP) and try again.,Mora postojati default dolazne omogućio da bi ovo radilo e-pošte. Molimo vas da postavljanje default dolazne e-pošte (POP / IMAP) i pokušajte ponovo.
-DocType: Healthcare Settings,Receivable Account,Potraživanja račun
-apps/erpnext/erpnext/controllers/accounts_controller.py +553,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} je već {2}
+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: Fee Schedule,Receivable Account,Potraživanja račun
+apps/erpnext/erpnext/controllers/accounts_controller.py +597,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 +316,Sales Order to Payment,Naloga prodaje na isplatu
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +119,CEO,CEO
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,CEO
 DocType: Purchase Invoice,With Payment of Tax,Uz plaćanje poreza
 DocType: Expense Claim Detail,Expense Claim Detail,Rashodi Zahtjev Detalj
 DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,Tri primjerka ZA SUPPLIER
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +868,Please select correct account,Molimo odaberite ispravan račun
-DocType: Item,Weight UOM,Težina UOM
+DocType: Land Unit,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 +869,Please select correct account,Molimo odaberite ispravan račun
+DocType: Purchase Invoice Item,Weight UOM,Težina UOM
 DocType: Salary Structure Employee,Salary Structure Employee,Plaća Struktura zaposlenih
-DocType: Patient,Blood Group,Krvna grupa
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Prikaži varijante atributa
+DocType: Student,Blood Group,Krvna grupa
 DocType: Course,Course Name,Naziv predmeta
 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 +52,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/industry_type.py +24,Electronics,Elektronika
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronika
 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/install_fixtures.py +94,Full-time,Puno radno vrijeme
-DocType: Salary Structure,Employees,Zaposleni
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,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
 DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Cijene neće biti prikazan ako nije postavljena Cjenik
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +28,Please specify a country for this Shipping Rule or check Worldwide Shipping,Molimo navedite zemlju za ovaj Dostava pravilo ili provjeriti dostavom diljem svijeta
 DocType: Stock Entry,Total Incoming Value,Ukupna vrijednost Incoming
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +352,Debit To is required,To je potrebno Debit
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +356,Debit To is required,To je potrebno Debit
 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 +39,Purchase Price List,Kupoprodajna cijena List
 apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Šabloni varijabli indeksa dobavljača.
 DocType: Offer Letter Term,Offer Term,Ponuda Term
-DocType: Quality Inspection,Quality Manager,Quality Manager
+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/industry_type.py +51,Technology,tehnologija
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,tehnologija
 DocType: Hub Settings,Unregister from Hub,Odjavite se iz Hub-a
 apps/erpnext/erpnext/public/js/utils.js +102,Total Unpaid: {0},Ukupno Neplaćeni: {0}
 DocType: BOM Website Operation,BOM Website Operation,BOM Web Operacija
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Ponuda Pismo
 apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Generirajte Materijal Upiti (MRP) i radne naloge.
 DocType: Supplier Scorecard,Supplier Score,Ocjena dobavljača
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +76,Total Invoiced Amt,Ukupno Fakturisana Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +87,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: Physician Schedule Time Slot,To Time,Za vrijeme
+DocType: Assessment Plan,To Time,Za vrijeme
 DocType: Authorization Rule,Approving Role (above authorized value),Odobravanje ulogu (iznad ovlašteni vrijednost)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Payable account,Credit na račun mora biti računa se plaćaju
-apps/erpnext/erpnext/schools/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 +335,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/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Credit na račun mora biti računa se plaćaju
+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 +338,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/hub_node/doctype/hub_settings/hub_settings.py +23,Please select a Price List to publish pricing,Izaberite cjenovnik za objavljivanje cijene
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Budžetska lista
 DocType: Production Order Operation,Completed Qty,Završen Kol
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry","Za {0}, samo debitne račune mogu povezati protiv druge kreditne unos"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +146,"For {0}, only debit accounts can be linked against another credit entry","Za {0}, samo debitne račune mogu povezati protiv druge kreditne unos"
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Cjenik {0} je onemogućen
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Red {0}: Završena Količina ne može biti više od {1} za rad {2}
 DocType: Manufacturing Settings,Allow Overtime,Omogućiti Prekovremeni rad
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"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 +976,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/physician_schedule/physician_schedule.js +6,Add Time Slots,Dodajte vremenske utore
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{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
@@ -2443,10 +2615,13 @@
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,"Dalje troška mogu biti pod Grupe, ali unosa može biti protiv ne-Grupe"
 apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Korisnici i dozvole
 DocType: Vehicle Log,VLOG.,VLOG.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +945,Production Orders Created: {0},Radne naloge Napisano: {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +994,Production Orders Created: {0},Radne naloge Napisano: {0}
 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: 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
@@ -2455,15 +2630,16 @@
 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
-apps/erpnext/erpnext/projects/doctype/project/project.py +203,You have been invited to collaborate on the project: {0},Vi ste pozvani da surađuju na projektu: {0}
+apps/erpnext/erpnext/projects/doctype/project/project.py +214,You have been invited to collaborate on the project: {0},Vi ste pozvani da surađuju na projektu: {0}
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Physician not available on {0},Lekar nije dostupan na {0}
 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/schools/doctype/student_admission/templates/student_admission.html +70,Apply Now,Prijavite se sada
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Prijavite se sada
 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
-apps/erpnext/erpnext/controllers/buying_controller.py +421,Expected Date cannot be before Transaction Date,Očekivani datum ne može biti pre Datum transakcije
+apps/erpnext/erpnext/controllers/buying_controller.py +422,Expected Date cannot be before Transaction Date,Očekivani datum ne može biti pre Datum transakcije
 ,Bank Clearance Summary,Razmak banka Sažetak
 apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Stvaranje i upravljanje dnevne , tjedne i mjesečne e razgradnju ."
 DocType: Appraisal Goal,Appraisal Goal,Procjena gol
@@ -2472,21 +2648,23 @@
 DocType: Fee Schedule,Fee Structure,naknada Struktura
 DocType: Timesheet Detail,Costing Amount,Costing Iznos
 DocType: Student Admission Program,Application Fee,naknada aplikacija
-DocType: Process Payroll,Submit Salary Slip,Slanje plaće Slip
-apps/erpnext/erpnext/controllers/selling_controller.py +165,Maxiumm discount for Item {0} is {1}%,Maxiumm popusta za točke {0} je {1} %
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,Submit Salary Slip,Slanje plaće Slip
+apps/erpnext/erpnext/controllers/selling_controller.py +133,Maxiumm discount for Item {0} is {1}%,Maxiumm popusta za točke {0} je {1} %
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Uvoz u rinfuzi
 DocType: Sales Partner,Address & Contacts,Adresa i kontakti
 DocType: SMS Log,Sender Name,Ime / Naziv pošiljaoca
+DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kriterijumi za analizu poljoprivrede
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +193,Sort by Criteria,Sortiraj prema kriterijumima
 DocType: POS Profile,[Select],[ izaberite ]
 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 +61,Softwares,softvera
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +50,Next Contact Date cannot be in the past,Sljedeća Kontakt datum ne može biti u prošlosti
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,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/healthcare/doctype/patient_appointment/patient_appointment.js +91,Physician {0} not available on {1},Lekar {0} nije dostupan na {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2519,Select Batch No,Izaberite serijski br
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Lekar {0} nije dostupan na {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2538,Select Batch No,Izaberite serijski br
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},{1}: Invalid {0}
 DocType: Purchase Invoice,PINV-RET-,PINV-RET-
 DocType: Fee Validity,Reference Inv,Reference Inv
@@ -2498,12 +2676,12 @@
 DocType: Employee,Employment Details,Zapošljavanje Detalji
 DocType: Employee,New Workplace,Novi radnom mjestu
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Postavi status Zatvoreno
-apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Barcode {0},No Stavka s Barcode {0}
+apps/erpnext/erpnext/stock/get_item_details.py +125,No Item with Barcode {0},No Stavka s Barcode {0}
 DocType: Normal Test Items,Require Result Value,Zahtevaj vrednost rezultata
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Slučaj broj ne može biti 0
 DocType: Item,Show a slideshow at the top of the page,Prikaži slideshow na vrhu stranice
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +514,Boms,Boms
-apps/erpnext/erpnext/stock/doctype/item/item.py +149,Stores,prodavaonice
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +517,Boms,Boms
+apps/erpnext/erpnext/stock/doctype/item/item.py +151,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 +27,Ageing Based On,Starenje temelju On
@@ -2518,17 +2696,19 @@
 DocType: Rename Tool,Rename Tool,Preimenovanje alat
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Update cost
 DocType: Item Reorder,Item Reorder,Ponovna narudžba artikla
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +446,Show Salary Slip,Pokaži Plaća Slip
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +823,Transfer Material,Prijenos materijala
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Pokaži Plaća Slip
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +848,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: Water Analysis,Origin,Poreklo
 apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,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 +1006,Please set recurring after saving,Molimo podesite ponavljaju nakon spremanja
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +758,Select change amount account,Izaberite promjene iznos računa
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1086,Please set recurring after saving,Molimo podesite ponavljaju nakon spremanja
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +763,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 +40,Cash Flow from Financing,Novčani tok iz Financiranje
 DocType: Budget Account,Budget Account,računa budžeta
@@ -2537,34 +2717,38 @@
 DocType: Grading Scale Interval,Grade Description,Grade Opis
 DocType: Stock Entry,Purchase Receipt No,Primka br.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,kapara
-DocType: Process Payroll,Create Salary Slip,Stvaranje plaće Slip
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,sljedivost
+DocType: Asset Maintenance Log,Actions performed,Izvršene akcije
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Izvor sredstava ( pasiva)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +381,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}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +406,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: Asset Repair,Failure Date,Datum otkaza
 DocType: Sample Collection,Collected Time,Prikupljeno vreme
 DocType: Company,Sales Monthly History,Prodaja mesečne istorije
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +204,Select Batch,Izaberite Batch
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} je u potpunosti naplaćeno
+DocType: Asset Maintenance Task,Next Due Date,Sljedeći datum roka
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Izaberite Batch
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +242,{0} {1} is fully billed,{0} {1} je u potpunosti naplaćeno
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +48,Vital Signs,Vitalni znaci
 DocType: Training Event,End Time,End Time
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Aktivni Plaća Struktura {0} nađeni za zaposlenog {1} za navedeni datumi
 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.
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Grupa po jamcu
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +186,Are you sure you want to cancel this appointment?,Da li ste sigurni da želite da otkažete ovaj termin?
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Da li ste sigurni da želite da otkažete ovaj termin?
 apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,prodaja Pipeline
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +216,Please set default account in Salary Component {0},Molimo podesite zadani račun u Plaća Komponenta {0}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,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/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 +270,Specified BOM {0} does not exist for Item {1},Navedene BOM {0} ne postoji za Stavka {1}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +221,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Raspored održavanja {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+apps/erpnext/erpnext/controllers/buying_controller.py +271,Specified BOM {0} does not exist for Item {1},Navedene BOM {0} ne postoji za Stavka {1}
+DocType: Soil Texture,Sandy Loam,Sandy Loam
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Raspored održavanja {0} mora biti otkazana prije poništenja ovu prodajnog naloga
 DocType: POS Profile,Applicable for Users,Primenljivo za korisnike
 DocType: Notification Control,Expense Claim Approved,Rashodi Zahtjev odobren
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,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/install_fixtures.py +151,Pharmaceutical,farmaceutski
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,farmaceutski
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Troškovi Kupljene stavke
 DocType: Selling Settings,Sales Order Required,Prodajnog naloga Obvezno
 DocType: Purchase Invoice,Credit To,Kreditne Da
@@ -2574,76 +2758,76 @@
 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 +217,Group node warehouse is not allowed to select for transactions,skladište Group čvor nije dozvoljeno da izaberete za transakcije
+apps/erpnext/erpnext/stock/utils.py +222,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: Warranty Claim,Raised By,Povišena Do
 DocType: Payment Gateway Account,Payment Account,Plaćanje računa
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +880,Please specify Company to proceed,Navedite Tvrtka postupiti
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +906,Please specify Company to proceed,Navedite Tvrtka postupiti
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Neto promjena u Potraživanja
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Compensatory Off,kompenzacijski Off
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,kompenzacijski Off
 DocType: Offer Letter,Accepted,Prihvaćeno
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,organizacija
+DocType: Grant Application,Organization,organizacija
 DocType: BOM Update Tool,BOM Update Tool,Alat za ažuriranje BOM
-apps/erpnext/erpnext/accounts/party.py +204,"Party account not specified, please setup default party account in company","Partijski račun nije naveden, molimo postavite podrazumevani račun stranke u preduzeću"
 DocType: SG Creation Tool Course,Student Group Name,Student Ime grupe
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Kreiranje naknada
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Kreiranje naknada
 apps/erpnext/erpnext/setup/doctype/company/company.js +62,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,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.
 DocType: Room,Room Number,Broj sobe
 apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Invalid referentni {0} {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +167,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) ne može biti veći nego što je planirana kolicina ({2}) u proizvodnoj porudzbini {3}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) 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/public/js/conf.js +28,User Forum,User Forum
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +305,Raw Materials cannot be blank.,Sirovine ne može biti prazan.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +488,"Could not update stock, invoice contains drop shipping item.","Nije mogao ažurirati zaliha, faktura sadrži drop shipping stavke."
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +308,Raw Materials cannot be blank.,Sirovine ne može biti prazan.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +492,"Could not update stock, invoice contains drop shipping item.","Nije mogao ažurirati zaliha, faktura sadrži drop shipping stavke."
 DocType: Lab Test Sample,Lab Test Sample,Primjer laboratorijskog testa
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +484,Quick Journal Entry,Brzi unos u dnevniku
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +492,Quick Journal Entry,Brzi unos u dnevniku
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,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
 DocType: Stock Entry,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}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} nije proslijedjen
-apps/erpnext/erpnext/config/stock.py +27,Requests for items.,Zahtjevi za stavke.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +102,Google Maps integration is not enabled,Integracija Google mapa nije omogućena
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,{0} {1} is not submitted,{0} {1} nije proslijedjen
 DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Poseban proizvodnja kako će biti izrađen za svakog gotovog dobrom stavke.
+DocType: Member,Membership Expiry Date,Datum isteka članstva
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} mora biti negativan za uzvrat dokumentu
 ,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 +106,The name of the institute for which you are setting up this system.,U ime Instituta za koju se postavljanje ovog sistema.
+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 +30,Latest price updated in all BOMs,Posljednja cijena ažurirana u svim BOM
-DocType: Fee Schedule,Successful,Uspešno
 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)
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +423,The following Production Orders were created:,stvoreni su sljedeći nalozi:
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +424,The following Production Orders were created:,stvoreni su sljedeći nalozi:
 DocType: Student Admission Program,Naming Series (for Student Applicant),Imenovanje serija (za studentske Podnositelj zahtjeva)
 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 +68,Total Absent,Ukupno Odsutan
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +794,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
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +823,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 +187,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 +999,Opportunity,Prilika (Opportunity)
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1024,Opportunity,Prilika (Opportunity)
 ,Completed Production Orders,Završeni Radni nalozi
 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 +247,{0} {1} is closed,{0} {1} je zatvoren
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +245,{0} {1} is closed,{0} {1} je zatvoren
 DocType: Email Digest,How frequently?,Koliko često?
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +57,Total Collected: {0},Ukupno prikupljeno: {0}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Ukupno prikupljeno: {0}
 DocType: Purchase Receipt,Get Current Stock,Kreiraj trenutne zalihe
 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
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Present
 DocType: Project,% Complete Method,% Complete Način
-apps/erpnext/erpnext/healthcare/setup.py +180,Drug,Lijek
+apps/erpnext/erpnext/healthcare/setup.py +181,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: Production Order,Actual End Date,Stvarni datum završetka
 DocType: BOM,Operating Cost (Company Currency),Operativni trošak (Company Valuta)
@@ -2651,12 +2835,12 @@
 DocType: Authorization Rule,Applicable To (Role),Odnosi se na (uloga)
 DocType: BOM Update Tool,Replace BOM,Zamijenite BOM
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Kod {0} već postoji
-DocType: Stock Entry,Purpose,Svrha
+DocType: Employee Advance,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: Production Order,Manufacture against Material Request,Proizvodnja protiv Materijal Upit
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Procena grupa:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,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)
@@ -2664,23 +2848,26 @@
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,Ostavite bez plate ne odgovara odobrenim Records Ostaviti Primjena
 DocType: Campaign,Campaign-.####,Kampanja-.####
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Sljedeći koraci
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +769,Please supply the specified items at the best possible rates,Molimo vas da dostavite navedene stavke na najbolji mogući stope
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +794,Please supply the specified items at the best possible rates,Molimo vas da dostavite navedene stavke na najbolji mogući stope
+DocType: Membership,USD,Američki dolar
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Napravite fakturu
 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 +75,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/buying/doctype/purchase_order/purchase_order.py +76,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/public/js/financial_statements.js +83,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 +119,Contract End Date must be greater than Date of Joining,Ugovor Datum završetka mora biti veći od dana ulaska u
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,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: Delivery Note,DN-,DN-
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}",Oba &quot;Raspored lekara&quot; i vrijeme po imenovanju &quot;moraju biti postavljeni za dr {0}
 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 +376,{0} against Purchase Order {1},{0} protiv narudzbine dobavljacu {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +374,{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 +37,Ageing Range 1,Starenje Range 1
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +226,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
@@ -2724,22 +2911,26 @@
  10. Dodavanje ili Oduzeti: Bilo da želite dodati ili oduzeti porez."
 DocType: Homepage,Homepage,homepage
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Izaberite lekar ...
+DocType: Grant Application,Grant Application Details ,Grant Application Details
 DocType: Purchase Receipt Item,Recd Quantity,RecD Količina
-apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +57,Fee Records Created - {0},Naknada Records Kreirano - {0}
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +59,Fee Records Created - {0},Naknada Records Kreirano - {0}
 DocType: Asset Category Account,Asset Category Account,Asset Kategorija računa
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +117,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/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Stock upis {0} nije podnesen
+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 +360,Select Attribute Values,Odaberite vrijednosti atributa
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +537,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 +44,Next Contact By cannot be same as the Lead Email Address,Sljedeća kontaktirati putem ne može biti isti kao Lead-mail adresa
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,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/config/accounts.py +338,"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice"
+apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informacije o donatorima.
+apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice"
 DocType: Lead Source,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;"
 DocType: Journal Entry,Credit Note,Kreditne Napomena
 DocType: Warranty Claim,Service Address,Usluga Adresa
+DocType: Asset Maintenance Task,Calibration,Kalibracija
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Furnitures i raspored
 DocType: Item,Manufacture,Proizvodnja
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Setup Company
@@ -2751,8 +2942,9 @@
 DocType: Opportunity,Customer / Lead Name,Kupac / Ime osobe koja je Lead
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Razmak Datum nije spomenuo
 apps/erpnext/erpnext/config/manufacturing.py +7,Production,proizvodnja
-DocType: Patient,Occupation,okupacija
+DocType: Guardian,Occupation,okupacija
 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: 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/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Ovo može biti zbog nekih nevažećih e-mail adresa u
@@ -2762,25 +2954,25 @@
 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/config/hr.py +228,Organization branch master.,Organizacija grana majstor .
-apps/erpnext/erpnext/controllers/accounts_controller.py +280, or ,ili
+apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Organizacija grana majstor .
+apps/erpnext/erpnext/controllers/accounts_controller.py +303, 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/public/js/setup_wizard.js +28,Education (beta),Obrazovanje (beta)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,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 +241,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
 DocType: Buying Settings,Default Buying Price List,Zadani cjenik kupnje
-DocType: Process Payroll,Salary Slip Based on Timesheet,Plaća za klađenje na Timesheet osnovu
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +113,No employee for the above selected criteria OR salary slip already created,No zaposlenih za gore odabrane kriterije ili plate klizanja već stvorio
+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 +19,Buying Rate,Procenat kupovine
 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 +131,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
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +140,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Molimo odaberite serijom za Stavka {0}. Nije moguće pronaći jednu seriju koja ispunjava ovaj zahtjev
 DocType: Hub Category,Parent Category,Kategorija roditelja
-DocType: Process Payroll,Select Employees,Odaberite Zaposleni
+DocType: Payroll Entry,Select Employees,Odaberite Zaposleni
 DocType: Opportunity,Potential Sales Deal,Potencijalni Sales Deal
 DocType: Complaint,Complaints,Žalbe
 DocType: Payment Entry,Cheque/Reference Date,Ček / Referentni datum
@@ -2789,7 +2981,7 @@
 DocType: Bank Reconciliation Detail,Payment Entry,plaćanje Entry
 DocType: Item,Quality Parameters,Parametara kvaliteta
 ,sales-browser,prodaja-preglednik
-apps/erpnext/erpnext/accounts/doctype/account/account.js +73,Ledger,Glavna knjiga
+apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Glavna knjiga
 DocType: Patient Medical Record,PMR-,PMR-
 DocType: Drug Prescription,Drug Code,Kodeks o lekovima
 DocType: Target Detail,Target  Amount,Ciljani iznos
@@ -2797,12 +2989,12 @@
 DocType: Shopping Cart Settings,Shopping Cart Settings,Košarica Settings
 DocType: Journal Entry,Accounting Entries,Računovodstvo unosi
 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}
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +29,Global POS Profile {0} already created for company {1},Global POS profil {0} već kreirali za poduzeće {1}
+DocType: Journal Entry Account,Reference Due Date,Referentni rok za dostavljanje
 DocType: Purchase Order,Ref SQ,Ref. SQ
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,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 +320,Not Paid and Not Delivered,Ne plaća i ne dostave
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,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: Delivery Note,DN-RET-,DN-RET-
@@ -2811,32 +3003,35 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Raspored održavanja ne stvara za sve stavke . Molimo kliknite na ""Generiraj raspored '"
 ,To Produce,proizvoditi
 apps/erpnext/erpnext/config/hr.py +93,Payroll,platni spisak
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +179,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Za red {0} u {1}. Uključiti {2} u tačka stope, redova {3} mora biti uključena"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Za red {0} u {1}. Uključiti {2} u tačka stope, redova {3} mora biti uključena"
 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
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +654,Please select an item in the cart,Molimo izaberite stavku u korpi
+DocType: Volunteer Skill,Volunteer Skill,Volonterska vještina
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +713,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/install_fixtures.py +70,Arrear,zaostatak
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Depreciation Amount during the period,Amortizacija Iznos u periodu
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,zaostatak
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Amortizacija Iznos u periodu
 apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,predložak invaliditetom ne smije biti zadani predložak
 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 +776,Delivery,Isporuka
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +823,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/templates/generators/item_group.html +36,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 +143,Set default inventory account for perpetual inventory,Postaviti zadani račun inventar za trajnu inventar
+apps/erpnext/erpnext/setup/doctype/company/company.py +140,Set default inventory account for perpetual inventory,Postaviti zadani račun inventar za trajnu inventar
 DocType: Item Reorder,Material Request Type,Materijal Zahtjev Tip
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +268,Accural Journal Entry for salaries from {0} to {1},Accural Journal Entry za plate od {0} do {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +824,"LocalStorage is full, did not save","LocalStorage je puna, nije spasio"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +85,Row {0}: UOM Conversion Factor is mandatory,Red {0}: UOM Faktor konverzije je obavezno
-apps/erpnext/erpnext/utilities/user_progress.py +214,Room Capacity,Kapacitet sobe
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural Journal Entry za plate od {0} do {1}
+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 +839,"LocalStorage is full, did not save","LocalStorage je puna, nije spasio"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +90,Row {0}: UOM Conversion Factor is mandatory,Red {0}: UOM Faktor konverzije je obavezno
+apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Kapacitet sobe
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref.
 DocType: Lab Test,LP-,LP-
 DocType: Healthcare Settings,Registration Fee,Kotizaciju
@@ -2850,16 +3045,17 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","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
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +130,Head of Marketing and Sales,Voditelj marketinga i prodaje
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +68,Income Tax,Porez na dohodak
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Voditelj marketinga i prodaje
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Porez na dohodak
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Ako je odabrano cijene Pravilo je napravljen za 'Cijena', to će prepisati cijenu s liste. Pravilnik o cenama cijena konačnu cijenu, tako da nema daljnje popust treba primijeniti. Stoga, u transakcijama poput naloga prodaje, narudžbenice itd, to će biti učitani u 'Rate' na terenu, nego 'Cijena List Rate ""na terenu."
 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 +98,Go to Letterheads,Idite u Letterheads
 DocType: Item Supplier,Item Supplier,Dobavljač artikla
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1107,Please enter Item Code to get batch no,Unesite kod Predmeta da se hrpa nema
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +827,Please select a value for {0} quotation_to {1},Molimo odabir vrijednosti za {0} quotation_to {1}
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1187,Please enter Item Code to get batch no,Unesite kod Predmeta da se hrpa nema
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +874,Please select a value for {0} quotation_to {1},Molimo odabir vrijednosti za {0} quotation_to {1}
 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 +199,"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"
+apps/erpnext/erpnext/accounts/doctype/account/account.py +185,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","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 +123,Gain/Loss on Asset Disposal,Dobit / Gubitak imovine Odlaganje
@@ -2872,10 +3068,11 @@
 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 +21,Not in Stock,Nije raspoloživo
+DocType: Volunteer,Volunteer Skills,Volonterske veštine
 DocType: Appraisal,HR User,HR korisnika
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +53,POS?,POS?
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,POS?,POS?
 DocType: Purchase Invoice,Taxes and Charges Deducted,Porezi i naknade oduzeti
-apps/erpnext/erpnext/hooks.py +138,Issues,Pitanja
+apps/erpnext/erpnext/hooks.py +142,Issues,Pitanja
 apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Status mora biti jedan od {0}
 DocType: Sales Invoice,Debit To,Rashodi za
 DocType: Restaurant Menu Item,Restaurant Menu Item,Restoran Menu Item
@@ -2883,60 +3080,62 @@
 DocType: Stock Ledger Entry,Actual Qty After Transaction,Stvarna količina nakon transakcije
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},Bez plaće slip pronađena između {0} i {1}
 ,Pending SO Items For Purchase Request,Otvorena SO Proizvodi za zahtjev za kupnju
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +35,Student Admissions,student Prijemni
-apps/erpnext/erpnext/accounts/party.py +364,{0} {1} is disabled,{0} {1} je onemogućena
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,student Prijemni
+apps/erpnext/erpnext/accounts/party.py +376,{0} {1} is disabled,{0} {1} je onemogućena
 DocType: Supplier,Billing Currency,Valuta plaćanja
 DocType: Sales Invoice,SINV-RET-,SINV-RET-
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +196,Extra Large,Ekstra veliki
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Ekstra veliki
+DocType: Crop,Scientific Name,Naučno ime
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Ukupno Leaves
 DocType: Consultation,In print,U štampi
 ,Profit and Loss Statement,Račun dobiti i gubitka
 DocType: Bank Reconciliation Detail,Cheque Number,Broj čeka
 ,Sales Browser,prodaja preglednik
 DocType: Journal Entry,Total Credit,Ukupna kreditna
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,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 +51,Local,Lokalno
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +540,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/install_fixtures.py +195,Large,Veliki
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Veliki
 DocType: Homepage Featured Product,Homepage Featured Product,Homepage Istaknuti proizvoda
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +236,All Assessment Groups,Sve procjene Grupe
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +246,All Assessment Groups,Sve procjene Grupe
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Novo skladište Ime
 apps/erpnext/erpnext/accounts/report/financial_statements.py +233,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/schools/doctype/student/student_dashboard.py +26,Fee,provizija
-apps/erpnext/erpnext/setup/doctype/company/company.js +124,Update in progress. It might take a while.,Ažuriranje je u toku. Možda će potrajati neko vrijeme.
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,provizija
+apps/erpnext/erpnext/setup/doctype/company/company.js +125,Update in progress. It might take a while.,Ažuriranje je u toku. Možda će potrajati neko vrijeme.
 DocType: Vehicle Log,Fuel Qty,gorivo Količina
 DocType: Production Order Operation,Planned Start Time,Planirani Start Time
 DocType: Course,Assessment,procjena
 DocType: Payment Entry Reference,Allocated,Izdvojena
-apps/erpnext/erpnext/config/accounts.py +275,Close Balance Sheet and book Profit or Loss.,Zatvori bilanca i knjiga dobit ili gubitak .
+apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Zatvori bilanca i knjiga dobit ili gubitak .
 DocType: Student Applicant,Application Status,Primjena Status
 DocType: Sensitivity Test Items,Sensitivity Test Items,Točke testa osjetljivosti
 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 +158,Quotation {0} is cancelled,Ponuda {0} je otkazana
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Ponuda {0} je otkazana
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Ukupno preostali iznos
 DocType: Sales Partner,Targets,Mete
 DocType: Price List,Price List Master,Cjenik Master
 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."
 ,S.O. No.,S.O. Ne.
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +199,Please create Customer from Lead {0},Kreirajte Kupca iz Poslovne prilike {0}
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,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 +52,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/schools/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}
+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: Employee,AB-,AB-
+DocType: Student,AB-,AB-
 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 +64,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozorenje: prodajnog naloga {0} već postoji protiv narudžbenice kupca {1}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,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:
@@ -2962,54 +3161,56 @@
  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 +233,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/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Ime greška: {0}
 apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Shortage,nedostatak
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not associated with {2} {3},{0} {1} ne u vezi sa {2} {3}
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,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
 DocType: C-Form Invoice Detail,Net Total,Osnovica
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +498,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/hr.py +163,Define various loan types,Definirati različite vrste kredita
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +526,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/hr.py +168,Define various loan types,Definirati različite vrste kredita
 DocType: Bin,FCFS Rate,FCFS Stopa
-DocType: Payment Reconciliation Invoice,Outstanding Amount,Izvanredna Iznos
+DocType: Opening Invoice Creation Tool 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 +124,Financial Year,Finansijska godina
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +41,{0} does not belong to Company {1},{0} ne pripada preduzecu {1}
+apps/erpnext/erpnext/public/js/setup_wizard.js +127,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 +119,Cost as on,Koštaju kao na
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Koštaju kao na
 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 +231,Quantity must be positive,Količina mora biti pozitivna
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +252,Quantity must be positive,Količina mora biti pozitivna
 ,Requested Qty,Traženi Kol
 DocType: Tax Rule,Use for Shopping Cart,Koristiti za Košarica
 apps/erpnext/erpnext/controllers/item_variant.py +96,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},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 +78,Select Serial Numbers,Odaberite serijski brojevi
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,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: Maintenance Visit,Purposes,Namjene
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,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
 ,Requested,Tražena
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,No Remarks,No Napomene
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,No Napomene
+DocType: Asset,In Maintenance,U održavanju
 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 +87,Root Account must be a group,Root račun mora biti grupa
+apps/erpnext/erpnext/accounts/doctype/account/account.py +86,Root Account must be a group,Root račun mora biti grupa
 DocType: Consultation,Drug Prescription,Prescription drugs
 DocType: Fees,FEE.,FEE.
 DocType: Employee Loan,Repaid/Closed,Otplaćen / Closed
 DocType: Item,Total Projected Qty,Ukupni planirani Količina
 DocType: Monthly Distribution,Distribution Name,Naziv distribucije
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Dobavljač&gt; Tip dobavljača
-apps/erpnext/erpnext/stock/stock_ledger.py +464,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","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"
+apps/erpnext/erpnext/stock/stock_ledger.py +471,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","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 +331,Quality Inspection required for Item {0},Provera kvaliteta potrebna za točke {0}
 DocType: POS Settings,Use POS in Offline Mode,Koristite POS u Offline načinu
@@ -3020,20 +3221,20 @@
 apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Spisak teritorija - upravljanje.
 DocType: Journal Entry Account,Sales Invoice,Faktura prodaje
 DocType: Journal Entry Account,Party Balance,Party Balance
-apps/erpnext/erpnext/accounts/page/pos/pos.js +484,Please select Apply Discount On,Molimo odaberite Apply popusta na
+apps/erpnext/erpnext/accounts/page/pos/pos.js +497,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: Process Payroll,Create Bank Entry for the total salary paid for the above selected criteria,Kreirajte banke unos za ukupne zarade isplaćene za gore odabrane kriterije
 DocType: Physician,Physician Schedule,Raspored lekara
 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.
 DocType: Subscription,Half-yearly,Polugodišnje
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +402,Accounting Entry for Stock,Računovodstvo Entry za Stock
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +406,Accounting Entry for Stock,Računovodstvo Entry za Stock
 DocType: Lab Test,LabTest Approver,LabTest Approver
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Ste već ocijenili za kriterije procjene {}.
+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
 DocType: Sales Invoice,Sales Team1,Prodaja Team1
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +39,Item {0} does not exist,Artikal {0} ne postoji
+apps/erpnext/erpnext/stock/doctype/item/item.py +521,Item {0} does not exist,Artikal {0} ne postoji
 DocType: Sales Invoice,Customer Address,Kupac Adresa
 DocType: Employee Loan,Loan Details,kredit Detalji
 DocType: Company,Default Inventory Account,Uobičajeno zaliha računa
@@ -3041,6 +3242,7 @@
 DocType: Antibiotic,Antibiotic Name,Antibiotički naziv
 DocType: Purchase Invoice,Apply Additional Discount On,Nanesite dodatni popust na
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Izaberite Tip ...
+DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,Veza sa svim zemljišnim jedinicama u kojima rastu usevi
 DocType: Account,Root Type,korijen Tip
 DocType: Item,FIFO,FIFO
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: ne mogu vratiti više od {1} {2} za tačka
@@ -3048,21 +3250,23 @@
 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 +150,Target warehouse is mandatory for row {0},Target skladište je obvezno za redom {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +155,Target warehouse is mandatory for row {0},Target skladište je obvezno za redom {0}
 DocType: Cheque Print Template,Primary Settings,primarni Postavke
 DocType: Purchase Invoice,Select Supplier Address,Izaberite dobavljač adresa
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +380,Add Employees,Dodaj zaposlenog
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Dodaj zaposlenog
 DocType: Purchase Invoice Item,Quality Inspection,Provjera kvalitete
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +192,Extra Small,Extra Small
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,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 +780,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/stock/doctype/material_request/material_request.js +805,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 +211,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/industry_type.py +29,"Food, Beverage & Tobacco","Hrana , piće i duhan"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +689,Can only make payment against unbilled {0},Mogu samo napraviti uplatu protiv nenaplaćenu {0}
-apps/erpnext/erpnext/controllers/selling_controller.py +130,Commission rate cannot be greater than 100,Proviziju ne može biti veća od 100
+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 +714,Can only make payment against unbilled {0},Mogu samo napraviti uplatu protiv nenaplaćenu {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +98,Commission rate cannot be greater than 100,Proviziju ne može biti veća od 100
+DocType: Volunteer,Volunteer,Dobrovoljno
 DocType: Stock Entry,Subcontract,Podugovor
 apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,Unesite {0} prvi
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +87,No replies from,Nema odgovora od
@@ -3071,60 +3275,68 @@
 DocType: Item,Manufacturer Part Number,Proizvođač Broj dijela
 DocType: Production Order Operation,Estimated Time and Cost,Procijenjena vremena i troškova
 DocType: Bin,Bin,Kanta
+DocType: Crop,Crop Name,Naziv žetve
 DocType: SMS Log,No of Sent SMS,Ne poslanih SMS
 DocType: Antibiotic,Healthcare Administrator,Administrator zdravstvene zaštite
 apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Postavite cilj
 DocType: Dosage Strength,Dosage Strength,Snaga doziranja
 DocType: Account,Expense Account,Rashodi račun
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,Software
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +199,Colour,Boja
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Software
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Boja
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Kriteriji Plan Procjena
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Sprečite kupovne naloge
-apps/erpnext/erpnext/healthcare/setup.py +257,Susceptible,Podložno
+apps/erpnext/erpnext/healthcare/setup.py +258,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 +52,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 +476,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})
+apps/erpnext/erpnext/controllers/accounts_controller.py +520,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/lab_test_template/lab_test_template.js +78,Change Code,Promeni kod
 DocType: Purchase Invoice Item,Valuation Rate,Vrednovanje Stopa
 DocType: Stock Reconciliation,SR/,SR /
 DocType: Vehicle,Diesel,dizel
-apps/erpnext/erpnext/stock/get_item_details.py +338,Price List Currency not selected,Cjenik valuta ne bira
+apps/erpnext/erpnext/stock/get_item_details.py +381,Price List Currency not selected,Cjenik valuta ne bira
 apps/erpnext/erpnext/config/healthcare.py +46,Results,Rezultati
 ,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/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Radnik {0} je već aplicirao za {1} iymeđu {2} i {3}
 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 +5,Until,Do
 DocType: Rename Tool,Rename Log,Preimenovanje Prijavite
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Student Grupe ili Terminski plan je obavezno
+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 +196,Go to Instructors,Idi na instruktore
+apps/erpnext/erpnext/utilities/user_progress.py +214,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 +135,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
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Memeber Activity,Memer aktivnost
 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/public/js/utils.js +264,Please select {0},Odaberite {0}
 DocType: C-Form,C-Form No,C-Obrazac br
 DocType: BOM,Exploded_items,Exploded_items
-apps/erpnext/erpnext/utilities/user_progress.py +118,List your products or services that you buy or sell.,Navedite svoje proizvode ili usluge koje kupujete ili prodajete.
+apps/erpnext/erpnext/utilities/user_progress.py +136,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: Employee Attendance Tool,Unmarked Attendance,Unmarked Posjeta
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +133,Researcher,istraživač
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,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}
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Ime ili e-obavezno
-apps/erpnext/erpnext/config/stock.py +168,Incoming quality inspection.,Dolazni kvalitete inspekcije.
 DocType: Purchase Order Item,Returned Qty,Vraćeni Količina
-DocType: Employee,Exit,Izlaz
-apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Root Type is mandatory,Korijen Tip je obvezno
+DocType: Student,Exit,Izlaz
+apps/erpnext/erpnext/accounts/doctype/account/account.py +158,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
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} trenutno ima {1} Scorecard stava i RFQs ovog dobavljača treba izdati oprezno.
+DocType: Chapter,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 +315,Serial No {0} created,Serijski Ne {0} stvorio
 DocType: Homepage,Company Description for website homepage,Kompanija Opis za web stranice homepage
@@ -3135,40 +3347,41 @@
 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/install_fixtures.py +221,Probationary Period,Probni rad
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Probationary Period,Probni rad
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Pregled {0}
 DocType: Customer Group,Only leaf nodes are allowed in transaction,Samo leaf čvorovi su dozvoljeni u transakciji
-DocType: Expense Claim,Expense Approver,Rashodi Approver
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Red {0}: Advance protiv Klijent mora biti kredit
-apps/erpnext/erpnext/accounts/doctype/account/account.js +83,Non-Group to Group,Non-grupe do grupe
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Serija je obavezno u nizu {0}
+DocType: Project,Total Costing Amount (via Timesheets),Ukupni iznos troškova (preko Timesheeta)
+DocType: Employee Advance,Expense Approver,Rashodi Approver
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +134,Row {0}: Advance against Customer must be credit,Red {0}: Advance protiv Klijent mora biti kredit
+apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Non-grupe do grupe
+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: Payment Entry,Pay,Platiti
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,To datuma i vremena
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +54,Course Schedules deleted:,Rasporedi Kurs izbrisan:
 apps/erpnext/erpnext/config/selling.py +297,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 +86,Printed On,otisnut na
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +97,Printed On,otisnut na
 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
 DocType: Patient Appointment,Reminded,Podsetio
 DocType: Patient,PID-,PID-
-apps/erpnext/erpnext/public/js/setup_wizard.js +103,Your Organization,Vaša organizacija
+DocType: Chapter Member,Chapter Member,Član poglavlja
+apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Vaša organizacija
 DocType: Fee Component,Fees Category,naknade Kategorija
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Please enter relieving date.,Unesite olakšavanja datum .
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Unesite olakšavanja datum .
 apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
 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/industry_type.py +38,Newspaper Publishers,novinski izdavači
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,novinski izdavači
 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 +114,Expected Delivery Date should be after Sales Order Date,Očekivani datum isporuke treba da bude nakon datuma prodaje
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,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/stock/get_item_details.py +302,Item Price updated for {0} in Price List {1},Artikal Cijena ažuriranje za {0} u Cjenik {1}
+apps/erpnext/erpnext/stock/get_item_details.py +345,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 +131,Account with child nodes cannot be converted to ledger,Konto sa pod-kontima se ne može pretvoriti u glavnoj knjizi
+apps/erpnext/erpnext/accounts/doctype/account/account.py +130,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
@@ -3177,15 +3390,15 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +85,Duplicate entry,Dupli unos
 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 +491,[Error],[Greska]
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +515,[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 +210,Limit Crossed,limit Crossed
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Planirani Upto
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,Preduzetnički kapital
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,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.
-apps/erpnext/erpnext/stock/doctype/item/item.py +474,"As there are existing transactions against item {0}, you can not change the value of {1}","Kao što je već postoje transakcije protiv stavku {0}, ne možete promijeniti vrijednost {1}"
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Planirani Upto
+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
@@ -3195,7 +3408,7 @@
 DocType: Payment Reconciliation Invoice,Invoice Number,Račun broj
 DocType: Shopping Cart Settings,Orders,Narudžbe
 DocType: Employee Leave Approver,Leave Approver,Ostavite odobravatelju
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +272,Please select a batch,Molimo odaberite serije
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,Molimo odaberite serije
 DocType: Assessment Group,Assessment Group Name,Procjena Ime grupe
 DocType: Manufacturing Settings,Material Transferred for Manufacture,Materijal za Preneseni Proizvodnja
 DocType: Expense Claim,"A user with ""Expense Approver"" role","Korisnik sa ""Rashodi Approver"" ulogu"
@@ -3204,21 +3417,23 @@
 ,Issued Items Against Production Order,Izdana Proizvodi prema proizvodnji Reda
 DocType: Antibiotic,Healthcare,Zdravstvena zaštita
 DocType: Target Detail,Target Detail,Ciljana Detalj
+apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Jedinstvena varijanta
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,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 +49,Period Closing Entry,Period zatvaranja Entry
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Izaberite Odeljenje ...
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,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 +360,Amount {0} {1} {2} {3},Broj {0} {1} {2} {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +361,Amount {0} {1} {2} {3},Broj {0} {1} {2} {3}
 DocType: Account,Depreciation,Amortizacija
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,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 +70,Avg. Selling Price List Rate,Avg. Prodajna cijena cena
 DocType: Production Plan Sales Order,Salse Order Date,Salse Order Datum
 DocType: Salary Component,Salary Component,Plaća Komponenta
-apps/erpnext/erpnext/accounts/utils.py +490,Payment Entries {0} are un-linked,Plaćanje Unosi {0} su un-povezani
+apps/erpnext/erpnext/accounts/utils.py +492,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/hub_node/page/hub/hub.js +195,Most Popular,Najpopularniji
@@ -3231,12 +3446,12 @@
 apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Predložak termina ili ugovor.
 DocType: Purchase Invoice,Address and Contact,Adresa i kontakt
 DocType: Cheque Print Template,Is Account Payable,Je nalog plaćaju
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +273,Stock cannot be updated against Purchase Receipt {0},Stock se ne može ažurirati protiv kupovine Prijem {0}
-DocType: Supplier,Last Day of the Next Month,Zadnji dan narednog mjeseca
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Stock se ne može ažurirati protiv kupovine Prijem {0}
+DocType: Company,Last Day of the Next Month,Zadnji dan narednog mjeseca
 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 +71,"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 +319,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/schools/doctype/program/program.js +8,Student Applicant,student zahtjeva
+apps/erpnext/erpnext/accounts/party.py +320,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: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL primatelja
 DocType: Asset Category Account,Accumulated Depreciation Account,Ispravka vrijednosti računa
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Ovaj e-mail je autogenerisan
@@ -3247,38 +3462,41 @@
 DocType: Activity Cost,Billing Rate,Billing Rate
 ,Qty to Deliver,Količina za dovođenje
 ,Stock Analytics,Stock Analytics
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +505,Operations cannot be left blank,Operacije se ne može ostati prazno
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +508,Operations cannot be left blank,Operacije se ne može ostati prazno
 DocType: Maintenance Visit Purpose,Against Document Detail No,Protiv dokumenta Detalj No
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +98,Party Type is mandatory,Party Tip je obavezno
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +99,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 +395,{0} {1} is cancelled or closed,{0} {1} je otkazan ili zatvoren
+apps/erpnext/erpnext/controllers/buying_controller.py +396,{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 +30,Net Cash from Investing,Neto novčani tok od investicione
 DocType: Production Order,Work-in-Progress Warehouse,Rad u tijeku Warehouse
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} mora biti dostavljena
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} mora biti dostavljena
 DocType: Fee Schedule Program,Total Students,Ukupno Studenti
-apps/erpnext/erpnext/schools/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 +354,Reference #{0} dated {1},Reference # {0} od {1}
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +161,Depreciation Eliminated due to disposal of assets,Amortizacija Eliminisan zbog raspolaganje imovinom
+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 +352,Reference #{0} dated {1},Reference # {0} od {1}
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Amortizacija Eliminisan zbog raspolaganje imovinom
+DocType: Member,Member,Član
 apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Upravljanje Adrese
-DocType: Asset,Item Code,Šifra artikla
+DocType: Pricing Rule,Item Code,Šifra artikla
 DocType: Production Planning Tool,Create Production Orders,Stvaranje radne naloge
 DocType: Serial No,Warranty / AMC Details,Jamstveni / AMC Brodu
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Izbor studenata ručno za grupe aktivnosti na osnovu
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,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
 DocType: Lead,Market Segment,Tržišni segment
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +924,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: Crop,Agriculture Manager,Poljoprivredni menadžer
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,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 +239,Closing (Dr),Zatvaranje (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Dr),Zatvaranje (Dr)
 DocType: Cheque Print Template,Cheque Size,Ček Veličina
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,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: School Settings,Current Academic Year,Trenutni akademske godine
+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/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Protiv zaposlenih kredita: {0}
@@ -3286,49 +3504,54 @@
 DocType: Production Planning Tool,Create Material Requests,Stvaranje materijalni zahtijevi
 DocType: Employee Education,School/University,Škola / Univerzitet
 DocType: Payment Request,Reference Details,Reference Detalji
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Očekivana vrijednost Nakon Korisni Život mora biti manja od bruto Kupovina Iznos
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Očekivana vrijednost Nakon Korisni Život mora biti manja od bruto Kupovina Iznos
 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: Asset,Double Declining Balance,Double degresivne
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +179,Closed order cannot be cancelled. Unclose to cancel.,Zatvorena kako se ne može otkazati. Otvarati da otkaže.
-DocType: Patient Relation,Father,otac
-apps/erpnext/erpnext/controllers/accounts_controller.py +562,'Update Stock' cannot be checked for fixed asset sale,&#39;Update Stock&#39; ne može se provjeriti na prodaju osnovnih sredstava
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Zatvorena kako se ne može otkazati. Otvarati da otkaže.
+DocType: Student Guardian,Father,otac
+apps/erpnext/erpnext/controllers/accounts_controller.py +606,'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 +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Račun {2} ne pripada kompaniji {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +147,Material Request {0} is cancelled or stopped,Materijal Zahtjev {0} je otkazan ili zaustavljen
-apps/erpnext/erpnext/config/hr.py +305,Leave Management,Ostavite Management
+apps/erpnext/erpnext/stock/doctype/item/item.js +366,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 +156,Material Request {0} is cancelled or stopped,Materijal Zahtjev {0} je otkazan ili zaustavljen
+apps/erpnext/erpnext/config/hr.py +310,Leave Management,Ostavite Management
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Grupa po računu
 DocType: Sales Order,Fully Delivered,Potpuno Isporučeno
 DocType: Lead,Lower Income,Niži Prihodi
 DocType: Restaurant Order Entry,Current Order,Trenutna porudžbina
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +169,Source and target warehouse cannot be same for row {0},Izvor i ciljna skladište ne može biti isti za redom {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +174,Source and target warehouse cannot be same for row {0},Izvor i ciljna skladište ne može biti isti za redom {0}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Razlika račun mora biti tip imovine / odgovornošću obzir, jer je to Stock Pomirenje je otvor za ulaz"
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,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 +155,Go to Programs,Idi na programe
+apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Idi na programe
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,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 +89,Purchase Order number required for Item {0},Broj narudžbenice kupnje je potreban za artikal {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +896,Production Order not created,Proizvodnog naloga kreiranu
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +943,Production Order not created,Proizvodnog naloga kreiranu
 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/schools/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}
+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
 ,Stock Projected Qty,Projektovana kolicina na zalihama
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,Customer {0} does not belong to project {1},Kupac {0} ne pripada projektu {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +438,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 Order,Customer's Purchase Order,Narudžbenica kupca
 DocType: Consultation,Patient,Pacijent
-apps/erpnext/erpnext/config/stock.py +117,Serial No and Batch,Serijski broj i Batch
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Provjerite kreditnu obavezu na nalogu za prodaju
+DocType: Land Unit,Check if it is a hydroponic unit,Proverite da li je to hidroponska jedinica
+apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,Serijski broj i Batch
 DocType: Warranty Claim,From Company,Iz Društva
-apps/erpnext/erpnext/schools/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/accounts/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Molimo podesite Broj Amortizacija Booked
+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 +77,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 +89,Value or Qty,"Vrijednost, ili kol"
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +425,Productions Orders cannot be raised for:,Productions naloga ne može biti podignuta za:
-apps/erpnext/erpnext/utilities/user_progress.py +126,Minute,Minuta
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,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: Payment Terms Template,Payment Terms,Uslovi plaćanja
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +426,Productions Orders cannot be raised for:,Productions naloga ne može biti podignuta za:
+apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minuta
 DocType: Purchase Invoice,Purchase Taxes and Charges,Kupnja Porezi i naknade
-apps/erpnext/erpnext/utilities/user_progress.py +100,Go to Suppliers,Idite na dobavljače
+DocType: Chapter,Meetup Embed HTML,Upoznajte Embed HTML
+apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Idite na dobavljače
 ,Qty to Receive,Količina za primanje
 DocType: Leave Block List,Leave Block List Allowed,Ostavite Block List dopuštenih
 DocType: Grading Scale Interval,Grading Scale Interval,Pravilo Scale Interval
@@ -3336,33 +3559,34 @@
 DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Popust (%) na Cjenovnik objekta sa margina
 apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Svi Skladišta
 DocType: Sales Partner,Retailer,Prodavač na malo
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +112,Credit To account must be a Balance Sheet account,Kredit na račun mora biti bilans stanja računa
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Kredit na račun mora biti bilans stanja računa
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Sve vrste dobavljača
+DocType: Donor,Donor,Donor
 DocType: Global Defaults,Disable In Words,Onemogućena u Words
-apps/erpnext/erpnext/stock/doctype/item/item.py +51,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 +97,Quotation {0} not of type {1},Ponuda {0} nije tip {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +49,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 +98,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/schools/doctype/fees/fees.js +105,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
+apps/erpnext/erpnext/education/doctype/fees/fees.js +105,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: Production Order,PRO-,PRO-
 DocType: Patient,Medical History,Medicinska istorija
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Bank Prekoračenje računa
 DocType: Patient,Patient ID,ID pacijenta
 DocType: Physician Schedule,Schedule Name,Ime rasporeda
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Provjerite plaće slip
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +813,Add All Suppliers,Dodajte sve dobavljače
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,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/buying/doctype/request_for_quotation/request_for_quotation.js +838,Add All Suppliers,Dodajte sve dobavljače
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +83,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 +75,Browse BOM,Browse BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,osigurani krediti
 DocType: Purchase Invoice,Edit Posting Date and Time,Edit knjiženja datuma i vremena
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +101,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}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,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 +72,Available Selling,Dostupna prodaja
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Početno stanje Equity
 DocType: Lead,CRM,CRM
 DocType: Purchase Invoice,N,N
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +24,Reconciliation,Pomirenje
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,ostali
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,ostali
 DocType: Appraisal,Appraisal,Procjena
 DocType: Purchase Invoice,GST Details,Detalji GST
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},E-mail poslati na dobavljač {0}
@@ -3371,22 +3595,23 @@
 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/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},Ostavite odobritelj mora biti jedan od {0}
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +66,Create Fees,Kreiraj naknade
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Kreiraj naknade
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Ukupno TROŠKA (preko fakturi)
 DocType: Training Event,Start Time,Start Time
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +377,Select Quantity,Odaberite Količina
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +399,Select Quantity,Odaberite Količina
 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 +64,Unsubscribe from this Email Digest,Odjavili od ovog mail Digest
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +803,Get Suppliers By,Uzmite dobavljača
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +828,Get Suppliers By,Uzmite dobavljača
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{0} nije pronađen za stavku {1}
-apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Courses,Idi na kurseve
+apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Idi na kurseve
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Poruka je poslana
-apps/erpnext/erpnext/accounts/doctype/account/account.py +101,Account with child nodes cannot be set as ledger,Račun s djetetom čvorovi se ne može postaviti kao glavnu knjigu
+apps/erpnext/erpnext/accounts/doctype/account/account.py +100,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 +229,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}
@@ -3402,12 +3627,14 @@
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +155,Source and target warehouse must be different,Izvor i meta skladište mora biti drugačiji
 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: Purchase Invoice Item,PR Detail,PR Detalj
+DocType: Driving License Category,Class,Klasa
 DocType: Sales Order,Fully Billed,Potpuno Naplaćeno
+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 +136,Delivery warehouse required for stock item {0},Isporuka skladište potrebno za zaliha stavku {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,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)
-apps/erpnext/erpnext/schools/doctype/course/course.js +3,Program,program
+apps/erpnext/erpnext/education/doctype/course/course.js +3,Program,program
 DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Korisnici s ovom ulogom smiju postaviti zamrznute račune i izradu / izmjenu računovodstvenih unosa protiv zamrznutih računa
 DocType: Serial No,Is Cancelled,Je otkazan
 DocType: Student Group,Group Based On,Grupa na osnovu
@@ -3415,15 +3642,15 @@
 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:"
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +128,Do you really want to Submit all Salary Slip from {0} to {1},Da li zaista želite da dostavi sve Plaća listić od {0} do {1}
+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
 DocType: Hub Settings,Publish Items to Hub,Objavite Stavke za Hub
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +43,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/install_fixtures.py +178,Wire Transfer,Wire Transfer
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +132,Check all,Provjerite sve
+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 +182,Wire Transfer,Wire Transfer
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Provjerite sve
 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
@@ -3432,19 +3659,18 @@
 DocType: Lab Test Template,Change In Item,Promenite stavku
 DocType: Payment Gateway Account,Default Payment Request Message,Uobičajeno plaćanje poruka zahtjeva
 DocType: Item Group,Check this if you want to show in website,Označite ovo ako želite pokazati u web
-apps/erpnext/erpnext/config/accounts.py +142,Banking and Payments,Bankarstvo i platni promet
+apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Bankarstvo i platni promet
 ,Welcome to ERPNext,Dobrodošli na ERPNext
 apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Potencijalni kupac do ponude
 DocType: Patient,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 +327,Calls,Pozivi
-apps/erpnext/erpnext/utilities/user_progress.py +122,A Product,A Product
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +197,Batches,serija
-DocType: Project,Total Costing Amount (via Time Logs),Ukupni troskovi ( iz Time Log-a)
-apps/erpnext/erpnext/schools/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Napravite raspored naknada
+apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,A Product
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,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 +230,Purchase Order {0} is not submitted,Narudžbenicu {0} nije podnesen
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Narudžbenicu {0} nije podnesen
 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: Production Order Item,Available Qty at WIP Warehouse,Dostupno Količina u WIP Skladište
@@ -3454,69 +3680,76 @@
 DocType: Notification Control,Quotation Message,Ponuda - poruka
 DocType: Employee Loan,Employee Loan Application,Zaposlenik Zahtjev za kredit
 DocType: Issue,Opening Date,Otvaranje Datum
-apps/erpnext/erpnext/schools/api.py +80,Attendance has been marked successfully.,Posjećenost je uspješno označen.
+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: 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 +165,Account Type for {0} must be {1},Tip naloga za {0} mora biti {1}
 DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Uobičajeni računi prihoda koji se koriste ako nisu postavljeni kod lekara za rezervisanje konsultantskih troškova.
 apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Lišće i privatnom
-DocType: School Settings,Current Academic Term,Trenutni Academic Term
+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 +77,Both Warehouse must belong to same Company,Oba skladišta moraju pripadati istom preduzeću
 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
 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
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Debit Note Amt,Debit note Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Debit Note Amt,Debit note Amt
 apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,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/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Odnos sa Guardian1
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,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 +797,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
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,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/schools/doctype/academic_year/academic_year.js +3,Student Group,student Group
+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 +56,"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"
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2005,Please select customer,Molimo odaberite kupac
+DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kriterijumi za analizu zemljišta
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2020,Please select customer,Molimo odaberite kupac
 DocType: C-Form,I,ja
 DocType: Company,Asset Depreciation Cost Center,Asset Amortizacija troškova Center
 DocType: Sales Order Item,Sales Order Date,Datum narudžbe kupca
 DocType: Sales Invoice Item,Delivered Qty,Isporučena količina
 DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Ako je označeno, sva djeca svake proizvodne artikl će biti uključeni u Industrijska zahtjevima."
 DocType: Assessment Plan,Assessment Plan,plan procjene
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Klijent {0} je kreiran.
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,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
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Nedostaje Valuta Tečaj za {0}
 DocType: Assessment Plan,Examiner,ispitivač
-DocType: Patient Relation,Siblings,braća i sestre
+DocType: Student,Siblings,braća i sestre
 DocType: Journal Entry,Stock Entry,Kataloški Stupanje
 DocType: Payment Entry,Payment References,plaćanje Reference
 DocType: C-Form,C-FORM-,C-oplate
 DocType: Vehicle,Insurance Details,osiguranje Detalji
 DocType: Account,Payable,Plativ
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Unesite rokovi otplate
-apps/erpnext/erpnext/shopping_cart/cart.py +365,Debtors ({0}),Dužnici ({0})
+apps/erpnext/erpnext/shopping_cart/cart.py +376,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 +75,Gross Profit %,Bruto dobit%
 DocType: Appraisal Goal,Weightage (%),Weightage (%)
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +489,Change POS Profile,Promenite POS profil
 DocType: Bank Reconciliation Detail,Clearance Date,Razmak Datum
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Izveštaj o proceni
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Bruto Kupovina Iznos je obavezno
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Izveštaj o proceni
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Bruto Kupovina Iznos je obavezno
 DocType: Lead,Address Desc,Adresa silazno
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +101,Party is mandatory,Party je obavezno
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +102,Party is mandatory,Party je obavezno
 DocType: Journal Entry,JV-,JV-
+apps/erpnext/erpnext/controllers/accounts_controller.py +687,Rows with duplicate due dates in other rows were found: {list},Redovi sa dupliciranim datumima u drugim redovima su pronađeni: {list}
 DocType: Topic,Topic Name,Topic Name
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,Barem jedan od prodajete ili kupujete mora biti odabran
-apps/erpnext/erpnext/public/js/setup_wizard.js +33,Select the nature of your business.,Odaberite priroda vašeg poslovanja.
+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
@@ -3526,19 +3759,21 @@
 Grouped for test templates which are a group of other test templates.
 <br>
 No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","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 +73,Row #{0}: Duplicate entry in References {1} {2},Row # {0}: duplikat unosa u Reference {1} {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +75,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.
 DocType: Asset Movement,Source Warehouse,Izvorno skladište
 DocType: Installation Note,Installation Date,Instalacija Datum
-apps/erpnext/erpnext/controllers/accounts_controller.py +541,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} ne pripada kompaniji {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +585,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} ne pripada kompaniji {2}
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Prodajna faktura {0} kreirana
 DocType: Employee,Confirmation Date,potvrda Datum
 DocType: C-Form,Total Invoiced Amount,Ukupno Iznos dostavnice
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,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: Employee Loan Application,Required by Date,Potreban po datumu
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +222,Closing Balance (Dr - Cr),Zatvaranje bilansa (Dr - Cr)
 DocType: Lead,Lead Owner,Vlasnik Lead-a
 DocType: Bin,Requested Quantity,Tražena količina
 DocType: Patient,Marital Status,Bračni status
@@ -3548,33 +3783,36 @@
 DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Bruto Pay - Ukupno odbitak - Otplata kredita
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +26,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 +45,Salary Slip ID,Plaća Slip ID
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date Of Retirement must be greater than Date of Joining,Datum umirovljenja mora biti veći od datuma pristupa
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +52,There were errors while scheduling course on :,"Bilo je grešaka, dok zakazivanje kurs na:"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,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 +68,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
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +95,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Stavka {0}: {1} Naručena količina ne može biti manji od minimalnog bi Količina {2} (iz točke).
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +96,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Stavka {0}: {1} Naručena količina ne može biti manji od minimalnog bi Količina {2} (iz točke).
 DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Mjesečni Distribucija Postotak
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +90,Please login as another user.,Molimo prijavite se kao drugi korisnik.
 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 +497,Please set default {0} in Company {1},Molimo podesite default {0} u kompaniji {1}
+apps/erpnext/erpnext/accounts/utils.py +499,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 +31,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
 DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Narudžbenica artikla Isporuka
-apps/erpnext/erpnext/public/js/setup_wizard.js +90,Company Name cannot be Company,Kompanija Ime ne može biti poduzeća
+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
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +201,Valuation type charges can not marked as Inclusive,Prijava tip vrednovanja ne može označiti kao Inclusive
+DocType: Member,Member Name,Ime člana
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,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/templates/emails/recurring_document_failed.html +10,in the subscription,u pretplati
 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: Membership,Payment Details,Detalji plaćanja
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Rate
 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/accounts/utils.py +467,Journal Entries {0} are un-linked,Journal unosi {0} su un-povezani
+apps/erpnext/erpnext/accounts/utils.py +469,Journal Entries {0} are un-linked,Journal unosi {0} su un-povezani
 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
@@ -3584,9 +3822,10 @@
 DocType: Buying Settings,Purchase Order Required,Narudžbenica kupnje je obavezna
 ,Item-wise Sales History,Stavka-mudar Prodaja Povijest
 DocType: Expense Claim,Total Sanctioned Amount,Ukupno kažnjeni Iznos
+DocType: Land Unit,Land Unit,Zemaljska jedinica
 ,Purchase Analytics,Kupnja Analytics
 DocType: Sales Invoice Item,Delivery Note Item,Stavka otpremnice
-DocType: Expense Claim,Task,Zadatak
+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 +13,This is a root sales person and cannot be edited.,To jekorijen prodavač i ne može se mijenjati .
@@ -3595,8 +3834,8 @@
 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
 apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Zaposleni i dolaznost
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +78,Purpose must be one of {0},Svrha mora biti jedan od {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,Fill the form and save it,Ispunite obrazac i spremite ga
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Purpose must be one of {0},Svrha mora biti jedan od {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +116,Fill the form and save it,Ispunite obrazac i spremite ga
 DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,Preuzmite izvješće koje sadrži sve sirovine sa svojim najnovijim statusom inventara
 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 +51,Actual qty in stock,Stvarne Količina na lageru
@@ -3609,7 +3848,7 @@
 DocType: Purchase Order,Get Items from Open Material Requests,Saznajte Predmeti od Open materijala Zahtjevi
 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
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +65,Reorder Qty,Ponovno red Qty
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +75,Reorder Qty,Ponovno red Qty
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,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
@@ -3620,36 +3859,41 @@
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +49,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,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
 apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Država mudar zadana adresa predlošci
+DocType: Water Analysis,Appearance,Izgled
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,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.
 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 +58,Asset Maintenance,Održavanje imovine
 ,Sales Payment Summary,Sažetak prodaje plata
 DocType: Restaurant,Restaurant,Restoran
-apps/erpnext/erpnext/accounts/party.py +322,Due / Reference Date cannot be after {0},Zbog / Reference Datum ne može biti nakon {0}
+apps/erpnext/erpnext/accounts/party.py +323,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: Patient,Account Details,Detalji konta
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +76,No students Found,No studenti Found
+DocType: Crop,Materials Required,Potrebni materijali
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,No studenti Found
 DocType: Medical Department,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: Sales Invoice,Rounded Total,Zaokruženi iznos
+DocType: Purchase Invoice,Rounded Total,Zaokruženi iznos
 DocType: Product Bundle,List items that form the package.,Popis stavki koje čine paket.
 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 +567,Please select Posting Date before selecting Party,Molimo odaberite Datum knjiženja prije izbora stranke
+DocType: Crop Cycle,Linked Land Unit,Linked Land Unit
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Molimo odaberite Datum knjiženja prije izbora stranke
 DocType: Program Enrollment,School House,School House
 DocType: Serial No,Out of AMC,Od AMC
-apps/erpnext/erpnext/public/js/utils.js +263,Please select Quotations,Molimo odaberite Citati
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +82,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
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,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
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Provjerite održavanja Posjetite
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +170,Please contact to the user who have Sales Master Manager {0} role,Molimo kontaktirajte za korisnike koji imaju Sales Manager Master {0} ulogu
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +198,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 +62,Company (not Customer or Supplier) master.,Društvo ( ne kupaca i dobavljača ) majstor .
-apps/erpnext/erpnext/schools/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/schools/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,No Studenti u
+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 +178,No Students in,No Studenti u
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +171,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 +206,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 +238,Go to Users,Idite na Korisnike
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +82,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/selling/doctype/sales_order/sales_order.py +212,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 +256,Go to Users,Idite na Korisnike
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,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 +149,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 +15,Invalid GSTIN or Enter NA for Unregistered,Nevažeći GSTIN ili Enter NA neregistriranim
@@ -3667,31 +3911,35 @@
 DocType: Hub Settings,Publish Availability,Objavite Dostupnost
 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 +107,Date of Birth cannot be greater than today.,Datum rođenja ne može biti veći nego što je danas.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,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
-apps/erpnext/erpnext/schools/doctype/student/student.py +38,Student {0} exist against student applicant {1},Student {0} postoje protiv podnosioca prijave student {1}
+apps/erpnext/erpnext/education/doctype/student/student.py +38,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/controllers/accounts_controller.py +233,{0} '{1}' is disabled,{0} '{1}' je onemogućeno
+DocType: Volunteer,Afternoon,Popodne
+apps/erpnext/erpnext/controllers/accounts_controller.py +256,{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
 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 +75,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 +65,Project {0} already exists,Projekat {0} već postoji
+apps/erpnext/erpnext/controllers/accounts_controller.py +100,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 +67,Project {0} already exists,Projekat {0} već postoji
 DocType: Medical Department,Nursing User,Korisnik medicinske sestre
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +227,Responsibilities,Odgovornosti
+DocType: Plant Analysis,Plant Analysis Criterias,Kriterijumi za analizu biljaka
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,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: 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 +226,Add Users,Dodaj Korisnici
+apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Dodaj Korisnici
 DocType: POS Item Group,Item Group,Grupa artikla
 DocType: Item,Safety Stock,Sigurnost Stock
 DocType: Healthcare Settings,Healthcare Settings,Postavke zdravstvene zaštite
@@ -3699,74 +3947,78 @@
 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 +445,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
+apps/erpnext/erpnext/stock/doctype/item/item.py +461,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,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/accounts/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Stavka {0} mora biti osnovna sredstva stavka
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Stavka {0} mora biti osnovna sredstva stavka
+apps/erpnext/erpnext/stock/doctype/item/item.js +341,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 +24,Debit Note Amount,Debitne Napomena Iznos
 apps/erpnext/erpnext/setup/doctype/company/company.js +60,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 +79,Total Outstanding Amt,Ukupno Outstanding Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Total Outstanding Amt,Ukupno Outstanding Amt
 DocType: Journal Entry,Printing Settings,Printing Settings
+DocType: Employee Advance,Advance Account,Advance Account
 DocType: Sales Invoice,Include Payment (POS),Uključuju plaćanje (POS)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,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/industry_type.py +11,Automotive,Automobilska industrija
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +290,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
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Variable,varijabla
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,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: Physician Schedule Time Slot,From Time,S vremena
+DocType: Assessment Plan,From Time,S vremena
 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/industry_type.py +33,Investment Banking,Investicijsko bankarstvo
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +78,Cash or Bank Account is mandatory for making payment entry,Novac ili bankovni račun je obvezna za izradu ulazak plaćanje
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,student adresa
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investicijsko bankarstvo
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Novac ili bankovni račun je obvezna za izradu ulazak plaćanje
+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/accounts/doctype/account/account.py +253,Account Number {0} already used in account {1},Broj računa {0} već se koristi na nalogu {1}
 DocType: POS Profile,POS Profile Name,POS Profil Ime
 DocType: Purchase Invoice Item,Rate,VPC
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +100,Intern,stažista
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1569,Address Name,Adresa ime
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,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/install_fixtures.py +69,Basic,Osnovni
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,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/config/stock.py +195,"e.g. Kg, Unit, Nos, m","npr. kg, Jedinica, br, m"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,Reference Ne obvezno ako ušao referentnog datuma
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,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 +110,Date of Joining must be greater than Date of Birth,Datum pristupa mora biti veći od datuma rođenja
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,Datum pristupa mora biti veći od datuma rođenja
 DocType: Salary Slip,Salary Structure,Plaća Struktura
 DocType: Account,Bank,Banka
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +9,Airline,Aviokompanija
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +827,Issue Material,Tiketi - materijal
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Aviokompanija
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +852,Issue Material,Tiketi - materijal
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Došlo je do greške prilikom stvaranja ponavljajuće
 DocType: Material Request Item,For Warehouse,Za galeriju
 DocType: Employee,Offer Date,ponuda Datum
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Citati
-apps/erpnext/erpnext/accounts/page/pos/pos.js +711,You are in offline mode. You will not be able to reload until you have network.,Vi ste u isključenom modu. Nećete biti u mogućnosti da ponovo sve dok imate mrežu.
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,No studentskih grupa stvorio.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +726,You are in offline mode. You will not be able to reload until you have network.,Vi ste u isključenom modu. Nećete biti u mogućnosti da ponovo sve dok imate mrežu.
+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/employee_loan/employee_loan.py +119,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 +55,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
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,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: Subscription,Next Schedule Date,Sledeći datum rasporeda
 DocType: Stock Entry,Including items for sub assemblies,Uključujući i stavke za pod sklopova
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1928,Enter value must be positive,Unesite vrijednost mora biti pozitivan
+DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Privremeni račun za otvaranje
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1943,Enter value must be positive,Unesite vrijednost mora biti pozitivan
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,Sve teritorije
 DocType: Purchase Invoice,Items,Artikli
-apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +26,Student is already enrolled.,Student je već upisana.
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +28,Student is already enrolled.,Student je već upisana.
 DocType: Fiscal Year,Year Name,Naziv godine
-DocType: Process Payroll,Process Payroll,Proces plaće
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Postoji više odmor nego radnih dana ovog mjeseca .
 DocType: Product Bundle Item,Product Bundle Item,Proizvod Bundle Stavka
 DocType: Sales Partner,Sales Partner Name,Prodaja Ime partnera
-apps/erpnext/erpnext/hooks.py +132,Request for Quotations,Zahtjev za ponudu
+apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Zahtjev za ponudu
 DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimalni iznos fakture
-apps/erpnext/erpnext/healthcare/setup.py +209,Haematology,Hematologija
+apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Hematologija
 DocType: Normal Test Items,Normal Test Items,Normalni testovi
 DocType: Student Language,Student Language,student Jezik
 apps/erpnext/erpnext/config/selling.py +23,Customers,Kupci
@@ -3776,11 +4028,12 @@
 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 +92,From and To dates required,Od i Do datuma zahtijevanih
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +46,Securities & Commodity Exchanges,Vrijednosni papiri i robne razmjene
-apps/erpnext/erpnext/stock/doctype/item/item.py +675,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;
+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 +661,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: Delivery Note Item,From Warehouse,Od Skladište
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +897,No Items with Bill of Materials to Manufacture,Nema artikala sa Bill materijala za proizvodnju
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Nema zaposlenih po navedenim kriterijumima
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +944,No Items with Bill of Materials to Manufacture,Nema artikala sa Bill materijala za proizvodnju
 DocType: Restaurant,Default Customer,Podrazumevani korisnik
 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
@@ -3790,40 +4043,41 @@
 DocType: Tax Rule,Shipping City,Dostava City
 DocType: Notification Control,Customize the Notification,Prilagodite Obavijest
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Novčani tok iz poslovanja
-DocType: Sales Invoice,Shipping Rule,Pravilo transporta
+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 +146,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: Process Payroll,Payroll Frequency,Payroll Frequency
+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
-DocType: Asset,Amended From,Izmijenjena Od
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +58,Raw Material,sirovine
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +62,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 +55,Plants and Machineries,Biljke i Machineries
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Iznos poreza Nakon iznosa popusta
 DocType: Daily Work Summary Settings,Daily Work Summary Settings,Svakodnevni rad Pregled Postavke
 DocType: Payment Entry,Internal Transfer,Interna Transfer
-apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Child account exists for this account. You can not delete this account.,Dijete računa postoji za taj račun . Ne možete izbrisati ovaj račun .
+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/stock/get_item_details.py +536,No default BOM exists for Item {0},Ne default BOM postoji točke {0}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +359,Please select Posting Date first,Molimo najprije odaberite Datum knjiženja
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +367,Please select Posting Date first,Molimo najprije odaberite Datum knjiženja
 apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Otvaranje Datum bi trebao biti prije zatvaranja datum
 DocType: Leave Control Panel,Carry Forward,Prenijeti
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Troška s postojećim transakcija ne može pretvoriti u knjizi
 DocType: Department,Days for which Holidays are blocked for this department.,Dani za koje su praznici blokirani za ovaj odjel.
+DocType: Crop Cycle,Detected Disease,Detektovana bolest
 ,Produced,Proizvedeno
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +118,Created Salary Slips,Stvorio Plaća Slips
 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
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +355,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/accounts/doctype/purchase_invoice/purchase_invoice.js +372,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 +234,Serial Nos Required for Serialized Item {0},Serijski Nos potrebna za serijaliziranom točke {0}
-apps/erpnext/erpnext/config/accounts.py +152,Match Payments with Invoices,Meč plaćanja fakture
+apps/erpnext/erpnext/config/accounts.py +144,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
@@ -3833,17 +4087,19 @@
 apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Dodaj u košaricu
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Group By
 DocType: Guardian,Interests,Interesi
-apps/erpnext/erpnext/config/accounts.py +306,Enable / disable currencies.,Omogućiti / onemogućiti valute .
+apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Omogućiti / onemogućiti valute .
 DocType: Production Planning Tool,Get Material Request,Get materijala Upit
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Poštanski troškovi
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Ukupno (Amt)
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,Zabava i slobodno vrijeme
+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
 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 +68,Total Present,Ukupno Present
-apps/erpnext/erpnext/config/accounts.py +113,Accounting Statements,knjigovodstvene isprave
+apps/erpnext/erpnext/config/accounts.py +105,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 +799,Please select Qty against item {0},Molimo izaberite Qty protiv stavke {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,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 +133,You are not authorized to approve leaves on Block Dates,Niste ovlašteni za odobravanje lišće na bloku Termini
@@ -3855,6 +4111,7 @@
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,nepoznat
 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
@@ -3862,77 +4119,86 @@
 DocType: GST Settings,GSTIN Email Sent On,GSTIN mail poslan
 DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop Guardian
 DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Napravite za punu količinu, već ignoriranje količina po narudžbi"
+DocType: Crop,Planting UOM,Sadnja UOM
 DocType: Account,Tax,Porez
-apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,neobilježen
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,neobilježen
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Otvaranje rezimea faktura
+DocType: Education Settings,Education Manager,Menadžer obrazovanja
 DocType: Production Planning Tool,Production Planning Tool,Planiranje proizvodnje alat
+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 +150,"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: C-Form,Invoices,Fakture
+DocType: Water Analysis,Type of Sample,Tip uzorka
 DocType: Batch,Source Document Name,Izvor Document Name
 DocType: Job Opening,Job Title,Titula
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} 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 +971,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
 apps/erpnext/erpnext/utilities/activation.py +99,Create Users,kreiranje korisnika
-apps/erpnext/erpnext/utilities/user_progress.py +126,Gram,gram
+apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,gram
 DocType: Supplier Scorecard,Per Month,Mjesečno
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +394,Quantity to Manufacture must be greater than 0.,Količina za proizvodnju mora biti veći od 0.
+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.
 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: POS Customer Group,Customer Group,Vrsta djelatnosti Kupaca
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +113,New Batch ID (Optional),New Batch ID (opcionalno)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +198,Expense account is mandatory for item {0},Rashodi račun je obvezna za predmet {0}
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +120,New Batch ID (Optional),New Batch ID (opcionalno)
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,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 +42,Net Change in Equity,Neto promjena u kapitalu
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +196,Newest,Najnoviji
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Molimo vas da otkaže fakturi {0} prvi
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Molimo vas da otkaže fakturi {0} prvi
 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
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +840,Receipt,priznanica
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Receipt,priznanica
 ,Sales Register,Prodaja Registracija
 DocType: Daily Work Summary Settings Company,Send Emails At,Pošalji e-mailova
 DocType: Quotation,Quotation Lost Reason,Razlog nerealizirane ponude
-apps/erpnext/erpnext/public/js/setup_wizard.js +19,Select your Domain,Odaberite Domain
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +367,Transaction reference no {0} dated {1},Transakcija Ref {0} od {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,Transaction reference no {0} dated {1},Transakcija Ref {0} od {1}
 apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.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 +419,Form View,Form View
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +476,Form View,Form View
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Sažetak za ovaj mjesec i aktivnostima na čekanju
-apps/erpnext/erpnext/utilities/user_progress.py +227,"Add users to your organization, other than yourself.","Dodajte korisnike u svoju organizaciju, osim sebe."
+apps/erpnext/erpnext/utilities/user_progress.py +245,"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 +98,No Customers yet!,Ne Kupci još!
 apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Izvještaj o novčanim tokovima
 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 +481,Please remove this Invoice {0} from C-Form {1},Molimo vas da uklonite ovu fakture {0} iz C-Form {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +485,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: Physician,Phone (R),Telefon (R)
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Dodato je vremenska utrka
 DocType: Item,Attributes,Atributi
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Omogući šablon
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +223,Please enter Write Off Account,Unesite otpis račun
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,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: Patient,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
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Računa {0} ne pripada kompaniji {1}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +873,Serial Numbers in row {0} does not match with Delivery Note,Serijski brojevi u nizu {0} ne odgovara otpremnica
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +878,Serial Numbers in row {0} does not match with Delivery Note,Serijski brojevi u nizu {0} ne odgovara otpremnica
 DocType: Student,Guardian Details,Guardian Detalji
 DocType: C-Form,C-Form,C-Form
 apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Prisustvo za više zaposlenih
+DocType: Agriculture Task,Start Day,Početak dana
 DocType: Vehicle,Chassis No,šasija Ne
 DocType: Payment Request,Initiated,Inicirao
 DocType: Production Order,Planned Start Date,Planirani Ozljede Datum
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +592,Please select a BOM,Izaberite BOM
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +596,Please select a BOM,Izaberite BOM
 DocType: Serial No,Creation Document Type,Tip stvaranje dokumenata
+DocType: Project Task,View Timesheet,View Timesheet
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Krajnji datum mora biti veći od početnog datuma
 DocType: Leave Type,Is Encash,Je li unovčiti
 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/schools/doctype/student_admission/templates/student_admission.html +30,End on,Završi
+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: Appraisal Template,Appraisal Template Title,Procjena Predložak Naslov
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Od datuma {0} za zaposlenog {1} ne može biti prije ulaska Datum zaposlenog {2}
 apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,trgovački
@@ -3944,32 +4210,34 @@
 DocType: Expense Claim,More Details,Više informacija
 DocType: Supplier Quotation,Supplier Address,Dobavljač Adresa
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} budžeta za računa {1} protiv {2} {3} je {4}. To će premašiti po {5}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +685,Row {0}# Account must be of type 'Fixed Asset',Red {0} # računa mora biti tipa &#39;osnovna sredstva&#39;
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +689,Row {0}# Account must be of type 'Fixed Asset',Red {0} # računa mora biti tipa &#39;osnovna sredstva&#39;
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Od kol
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,i unchcked Onemogućeno u
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Serija je obvezno
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,financijske usluge
+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/hub_node/page/hub/hub.js +457,Supplier Email,E-pošta dobavljača
 apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Vrste aktivnosti za vrijeme Trupci
-DocType: Tax Rule,Sales,Prodaja
+DocType: Opening Invoice Creation Tool,Sales,Prodaja
 DocType: Stock Entry Detail,Basic Amount,Osnovni iznos
 DocType: Training Event,Exam,ispit
 DocType: Complaint,Complaint,Žalba
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +452,Warehouse required for stock Item {0},Skladište je potrebno za skladišne proizvode {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +456,Warehouse required for stock Item {0},Skladište je potrebno za skladišne proizvode {0}
 DocType: Leave Allocation,Unused leaves,Neiskorišteni lišće
 DocType: Patient,Alcohol Past Use,Upotreba alkohola u prošlosti
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +179,Cr,Cr
+DocType: Fertilizer Content,Fertilizer Content,Sadržaj đubriva
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +188,Cr,Cr
 DocType: Tax Rule,Billing State,State billing
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +276,Transfer,Prijenos
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +891,Fetch exploded BOM (including sub-assemblies),Fetch eksplodirala BOM (uključujući i podsklopova )
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +296,Transfer,Prijenos
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +916,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 +113,Due Date is mandatory,Due Date je obavezno
+apps/erpnext/erpnext/controllers/accounts_controller.py +135,Due Date is mandatory,Due Date je obavezno
 apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Prirast za Atributi {0} ne može biti 0
 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: Supplier,Contact HTML,Kontakt HTML
+DocType: Disease,Treatment Period,Period lečenja
 ,Inactive Customers,neaktivnih kupaca
 DocType: Student Admission Program,Maximum Age,Maksimalno doba
 DocType: Landed Cost Voucher,LCV,LCV
@@ -3978,13 +4246,13 @@
 DocType: Stock Entry,Delivery Note No,Otpremnica br
 DocType: Production Planning Tool,"If checked, only Purchase material requests for final raw materials will be included in the Material Requests. Otherwise, Material Requests for parent items will be created","Ako je označeno, samo o kupovini materijala zahtjeva za konačnu sirovina će biti uključeni u Industrijska zahtjevima. U suprotnom, bit će stvoren Materijal Zahtjevi za roditelja stavke"
 DocType: Cheque Print Template,Message to show,Poruke za prikaz
-DocType: Company,Retail,Maloprodaja
-DocType: Attendance,Absent,Odsutan
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +566,Product Bundle,Bundle proizvoda
+apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Maloprodaja
+DocType: Student Attendance,Absent,Odsutan
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,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 +212,Row {0}: Invalid reference {1},Red {0}: Invalid referentni {1}
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +206,No submitted Delivery Notes found,Nema podnesenih beleški isporuke
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +210,Row {0}: Invalid reference {1},Red {0}: Invalid referentni {1}
 DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kupiti poreza i naknada Template
-DocType: Upload Attendance,Download Template,Preuzmite predložak
 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
@@ -3995,30 +4263,34 @@
 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 +112,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 +782,Send Supplier Emails,Pošalji dobavljač Email
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +807,Send Supplier Emails,Pošalji dobavljač Email
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plaća je već pripremljena za period od {0} i {1}, Ostavi period aplikacija ne može da bude između tog datuma opseg."
-apps/erpnext/erpnext/config/stock.py +132,Installation record for a Serial No.,Instalacijski zapis za serijski broj
 DocType: Guardian Interest,Guardian Interest,Guardian interesa
-apps/erpnext/erpnext/config/accounts.py +327,Setup default values for POS Invoices,Podesi podrazumevane vrednosti za POS Račune
-apps/erpnext/erpnext/config/hr.py +177,Training,trening
+DocType: Volunteer,Availability,Dostupnost
+apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Podesi podrazumevane vrednosti za POS Račune
+apps/erpnext/erpnext/config/hr.py +182,Training,trening
 DocType: Timesheet,Employee Detail,Detalji o radniku
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,Guardian1 Email ID
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Sljedeći datum dan i Ponovite na Dan Mjesec mora biti jednak
 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/buying/doctype/request_for_quotation/request_for_quotation.py +38,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}
+DocType: Delivery Stop,Select/Unselect Delivery Notes,Izaberite / opozovite beleške o isporuci
 DocType: Offer Letter,Awaiting Response,Čeka se odgovor
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Iznad
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1298,Total Amount {0},Ukupni iznos {0}
-apps/erpnext/erpnext/controllers/item_variant.py +232,Invalid attribute {0} {1},Nevažeći atributa {0} {1}
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1375,Total Amount {0},Ukupni iznos {0}
+apps/erpnext/erpnext/controllers/item_variant.py +301,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/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',"Molimo odaberite grupu procjene, osim &#39;Svi Procjena grupe&#39;"
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',"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
-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 .
+DocType: Agriculture Analysis Criteria,Water Analysis,Analiza vode
+DocType: Chapter,Region,Regija
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,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 +108,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 +96,Provisional Profit / Loss (Credit),Privremeni dobit / gubitak (Credit)
 DocType: Sales Invoice,Return Against Sales Invoice,Vratiti Protiv Sales fakture
@@ -4030,11 +4302,10 @@
 ,Monthly Attendance Sheet,Mjesečna posjećenost list
 DocType: Production Order Item,Production Order Item,Proizvodnog naloga Stavka
 apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Ne rekord naći
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost of Scrapped Asset,Troškovi Rashodovan imovine
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Troškovi Rashodovan imovine
 apps/erpnext/erpnext/controllers/stock_controller.py +236,{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 +659,Get Items from Product Bundle,Saznajte Predmeti od Bundle proizvoda
-apps/erpnext/erpnext/stock/doctype/item/item.py +663,"As stock exists against an item {0}, you can not enable has variants property","Pošto postoji zaliha u odnosu na stavku {0}, ne možete omogućiti svojstvo varijanti"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +684,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 +64,Split,Podijeliti
@@ -4045,6 +4316,8 @@
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Zadnje Komunikacija Datum
 DocType: Sales Team,Contact No.,Kontakt broj
 DocType: Bank Reconciliation,Payment Entries,plaćanje unosi
+DocType: Land Unit,Land Unit Details,Detalji o zemljištu
+DocType: Land Unit,Latitude,Latitude
 DocType: Production Order,Scrap Warehouse,Scrap Skladište
 DocType: Production 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
@@ -4057,77 +4330,83 @@
 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 +68,Total (Credit),Ukupno (kredit)
 DocType: Repayment Schedule,Payment Date,Datum plaćanja
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +107,New Batch Qty,New Batch Količina
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +10,Apparel & Accessories,Odjeća i modni dodaci
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +114,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/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 +28,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"
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +56,Opening Value,otvaranje vrijednost
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +66,Opening Value,otvaranje vrijednost
 DocType: Salary Detail,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
+DocType: Purchase Invoice Item,Total Weight,Ukupna tezina
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Komisija za prodaju
 DocType: Offer Letter Term,Value / Description,Vrijednost / Opis
-apps/erpnext/erpnext/controllers/accounts_controller.py +565,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} ne može se podnijeti, to je već {2}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +609,"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 +132,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: Asset Maintenance Task,Assign To Name,Dodeli ime
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Zabava Troškovi
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +48,Make Material Request,Make Materijal Upit
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +63,Make Material Request,Make Materijal Upit
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Otvorena Stavka {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodaja Račun {0} mora biti otkazana prije poništenja ovu prodajnog naloga
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,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: Consultation,Age,Starost
 DocType: Sales Invoice Timesheet,Billing Amount,Billing Iznos
 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/config/hr.py +60,Applications for leave.,Prijave za odsustvo.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account with existing transaction can not be deleted,Konto sa postojećim transakcijama se ne može izbrisati
+apps/erpnext/erpnext/accounts/doctype/account/account.py +166,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 +102,Legal Expenses,Pravni troškovi
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +130,Please select quantity on row ,Molimo odaberite Količina na red
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Molimo odaberite Količina na red
+apps/erpnext/erpnext/config/accounts.py +277,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/healthcare/doctype/patient_appointment/patient_appointment.py +102,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.",&quot;Vreme po imenovanju&quot; nije postavljeno za Dr {0}. Dodajte ga u glavu lekara.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,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 +135,No Item with Serial No {0},No Stavka s rednim brojem {0}
+apps/erpnext/erpnext/stock/get_item_details.py +129,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 +79,Direct Expenses,Direktni troškovi
+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
 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 +119,Travel Expenses,putni troškovi
 DocType: Maintenance Visit,Breakdown,Slom
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Dodajte prilagođeno polje Pretplata u doctype {0}
-apps/erpnext/erpnext/controllers/accounts_controller.py +677,Account: {0} with currency: {1} can not be selected,Račun: {0} s valutnom: {1} se ne mogu odabrati
+apps/erpnext/erpnext/controllers/accounts_controller.py +789,Account: {0} with currency: {1} can not be selected,Račun: {0} s valutnom: {1} se ne mogu odabrati
+DocType: Purchase Receipt Item,Sample Quantity,Količina uzorka
 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: Bank Reconciliation Detail,Cheque Date,Datum čeka
-apps/erpnext/erpnext/accounts/doctype/account/account.py +54,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/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Konto {0}: Nadređeni konto {1} ne pripada preduzeću: {2}
 DocType: Program Enrollment Tool,Student Applicants,student Kandidati
 apps/erpnext/erpnext/setup/doctype/company/company.js +77,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 +21,As on Date,Kao i na datum
 DocType: Appraisal,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/install_fixtures.py +96,Probation,Probni rad
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,Probni rad
 apps/erpnext/erpnext/config/hr.py +115,Salary Components,Plaća Komponente
 DocType: Program Enrollment Tool,New Academic Year,Nova akademska godina
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +762,Return / Credit Note,Povratak / Credit Note
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +809,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 +23,Total Paid Amount,Ukupno uplaćeni iznos
 DocType: Production Order Item,Transferred Qty,prebačen Kol
 apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigacija
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +184,Planning,planiranje
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,planiranje
 DocType: Material Request,Issued,Izdao
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +14,Student Activity,student aktivnost
-DocType: Project,Total Billing Amount (via Time Logs),Ukupna naplata (iz Time Log-a)
+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 +264,Quantity should be greater than 0,Količina bi trebao biti veći od 0
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +267,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: Leave Application,Half Day Date,Pola dana datum
@@ -4136,22 +4415,25 @@
 apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Tip lišća poput casual, bolovanja i sl."
 DocType: Email Digest,Send regular summary reports via Email.,Pošalji redovne zbirne izvještaje putem e-maila.
 DocType: Payment Entry,PE-,PE
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +254,Please set default account in Expense Claim Type {0},Molimo podesite zadani račun u Rashodi Preuzmi Tip {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +305,Please set default account in Expense Claim Type {0},Molimo podesite zadani račun u Rashodi Preuzmi Tip {0}
 DocType: Assessment Result,Student Name,ime studenta
 DocType: Brand,Item Manager,Stavka Manager
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Payroll plaćaju
 DocType: Buying Settings,Default Supplier Type,Zadani tip dobavljača
+DocType: Plant Analysis,Collection Datetime,Kolekcija Datetime
 DocType: Production Order,Total Operating Cost,Ukupni trošak
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,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.
-apps/erpnext/erpnext/public/js/setup_wizard.js +67,Company Abbreviation,Skraćeni naziv preduzeća
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Skraćeni naziv preduzeća
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Korisnik {0} ne postoji
+DocType: Payment Term,Day(s) after invoice date,Dan (a) nakon datuma fakture
+DocType: Payment Schedule,Payment Schedule,Raspored plaćanja
 DocType: Subscription,SUB-,SUB-
 DocType: Item Attribute Value,Abbreviation,Skraćenica
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,Plaćanje Entry već postoji
 apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Ne authroized od {0} prelazi granice
 apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Plaća predložak majstor .
-apps/erpnext/erpnext/healthcare/setup.py +240,Pathology,Patologija
+apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Patologija
 DocType: Restaurant Order Entry,Restaurant Table,Restoran Stol
 DocType: Leave Type,Max Days Leave Allowed,Max Dani Ostavite dopuštenih
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Set poreza Pravilo za košarica
@@ -4164,52 +4446,56 @@
 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/install_fixtures.py +139,All Customer Groups,Sve grupe kupaca
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Sve grupe kupaca
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,akumulirani Mjesečno
-apps/erpnext/erpnext/controllers/accounts_controller.py +638,{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/controllers/accounts_controller.py +750,{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/accounts/doctype/tax_rule/tax_rule.py +41,Tax Template is mandatory.,Porez Template je obavezno.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} does not exist,Konto {0}: Nadređeni konto {1} ne postoji
+apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Konto {0}: Nadređeni konto {1} ne postoji
 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
 DocType: Lab Prescription,Test Created,Test Created
 DocType: Healthcare Settings,Custom Signature in Print,Prilagođeni potpis u štampi
 DocType: Account,Temporary,Privremen
 DocType: Program,Courses,kursevi
 DocType: Monthly Distribution Percentage,Percentage Allocation,Postotak Raspodjela
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +124,Secretary,Sekretarica
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Sekretarica
 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"
 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 +1213,Please set Company,Molimo podesite Company
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1289,Please set Company,Molimo podesite Company
 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: Patient,AB Negative,AB Negativ
 DocType: Sample Collection,SMPL-,SMPL-
 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 +140,Creditors,Kreditori
 DocType: Assessment Plan,Assessment Name,procjena ime
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,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
-apps/erpnext/erpnext/public/js/setup_wizard.js +67,Institute Abbreviation,Institut Skraćenica
+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 +941,Supplier Quotation,Dobavljač Ponuda
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +966,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 +153,Quantity ({0}) cannot be a fraction in row {1},Količina ({0}) ne može biti frakcija u nizu {1}
 DocType: Consultation,C-,C-
 DocType: Attendance,ATT-,ATT-
-apps/erpnext/erpnext/stock/doctype/item/item.py +457,Barcode {0} already used in Item {1},Barkod {0} se već koristi u artiklu {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +473,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: 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/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} je obavezno za povratak
 DocType: Purchase Order,To Receive,Da Primite
-apps/erpnext/erpnext/utilities/user_progress.py +231,user@example.com,user@example.com
+apps/erpnext/erpnext/utilities/user_progress.py +249,user@example.com,user@example.com
+DocType: Asset,Asset Owner,Vlasnik imovine
 DocType: Employee,Personal Email,Osobni e
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,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/industry_type.py +15,Brokerage,posredništvo
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,posredništvo
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Posjećenost za zaposlenog {0} je već označena za ovaj dan
 DocType: Production Order Operation,"in Minutes
 Updated via 'Time Log'","u minutama 
@@ -4217,15 +4503,15 @@
 DocType: Customer,From Lead,Od Lead-a
 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 +66,Select Fiscal Year...,Odaberite fiskalnu godinu ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +557,POS Profile required to make POS Entry,POS Profil potrebno da bi POS upis
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +561,POS Profile required to make POS Entry,POS Profil potrebno da bi POS upis
 DocType: Program Enrollment Tool,Enroll Students,upisati studenti
 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 +138,Atleast one warehouse is mandatory,Atleast jednom skladištu je obavezno
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +143,Atleast one warehouse is mandatory,Atleast jednom skladištu je obavezno
 DocType: Serial No,Out of Warranty,Od jamstvo
 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 +360,{0} against Sales Invoice {1},{0} protiv prodaje fakture {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +358,{0} against Sales Invoice {1},{0} protiv prodaje fakture {1}
 DocType: Antibiotic,Laboratory User,Laboratorijski korisnik
 DocType: Sales Invoice,SINV-,SINV-
 DocType: Request for Quotation Item,Project Name,Naziv projekta
@@ -4235,43 +4521,47 @@
 DocType: Stock Ledger Entry,Stock Value Difference,Stock Vrijednost razlika
 apps/erpnext/erpnext/config/learn.py +234,Human Resource,Human Resource
 DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Pomirenje Plaćanje Plaćanje
+DocType: Disease,Treatment Task,Tretman zadataka
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,porezna imovina
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +626,Production Order has been {0},Proizvodnja Poretka bio je {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +630,Production Order has been {0},Proizvodnja Poretka bio je {0}
 DocType: BOM Item,BOM No,BOM br.
 DocType: Instructor,INS/,INS /
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,Journal Entry {0} does not have account {1} or already matched against other voucher,Journal Entry {0} nema obzir {1} ili su već usklađene protiv drugih vaučer
+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,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 +46,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 +49,Leaves must be allocated in multiples of 0.5,"Listovi moraju biti dodijeljeno u COMBI 0,5"
 DocType: Production Order,Operation Cost,Operacija Cost
 apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Prenesi dolazak iz. Csv datoteku
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Izvanredna Amt
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,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 ]
-apps/erpnext/erpnext/controllers/accounts_controller.py +535,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset je obavezan za osnovno sredstvo kupovinu / prodaju
+apps/erpnext/erpnext/controllers/accounts_controller.py +579,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset je obavezan za osnovno sredstvo kupovinu / prodaju
+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/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/config/hr.py +132,Types of Expense Claim.,Vrste Rashodi zahtjevu.
-apps/erpnext/erpnext/controllers/selling_controller.py +176,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}
+apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Vrste Rashodi zahtjevu.
+apps/erpnext/erpnext/controllers/selling_controller.py +144,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: Item,Taxes,Porezi
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +324,Paid and Not Delivered,Platio i nije dostavila
+DocType: Purchase Invoice Item,Weight Per Unit,Težina po jedinici
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Platio i nije dostavila
 DocType: Project,Default Cost Center,Standard Cost Center
 DocType: Bank Guarantee,End Date,Datum završetka
 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: Depreciation Schedule,Accumulated Depreciation Amount,Ispravka vrijednosti iznos
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Private Equity
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity
 DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Varijabilni pokazatelj dobavljača
 DocType: Employee Loan,Fully Disbursed,potpuno Isplaćeno
 DocType: Maintenance Visit,Customer Feedback,Ocjena Kupca
 DocType: Account,Expense,rashod
-apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Rezultat ne može biti veća od maksimalne Score
-apps/erpnext/erpnext/utilities/user_progress.py +108,Customers and Suppliers,Kupci i dobavljači
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Rezultat ne može biti veća od maksimalne Score
+apps/erpnext/erpnext/utilities/user_progress.py +126,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
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},Sintaksa greška u formuli ili stanja: {0}
@@ -4280,6 +4570,7 @@
 DocType: Appraisal,APRSL,APRSL
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Submit this Production Order for further processing.,Pošaljite ovaj radnog naloga za daljnju obradu .
 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 +27,Jobs,Posao
 ,Sales Order Trends,Prodajnog naloga trendovi
@@ -4288,21 +4579,23 @@
 ,Employee Information,Informacija o zaposlenom
 DocType: Stock Entry Detail,Additional Cost,Dodatni trošak
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"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 +891,Make Supplier Quotation,Provjerite Supplier kotaciji
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +916,Make Supplier Quotation,Provjerite Supplier kotaciji
 DocType: Quality Inspection,Incoming,Dolazni
-apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Evidencija Rezultat zapisa {0} već postoji.
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Evidencija Rezultat zapisa {0} već postoji.
 DocType: BOM,Materials Required (Exploded),Materijali Obavezno (eksplodirala)
 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 +66,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 +101,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: {1} Serial No ne odgovara {2} {3}
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,za stvaranje ponavljajuće
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +82,Casual Leave,Casual dopust
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Casual dopust
 apps/erpnext/erpnext/config/healthcare.py +138,Lab Test UOM.,Lab Test UOM.
+DocType: Agriculture Task,End Day,Krajnji dan
 DocType: Batch,Batch ID,ID serije
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Napomena : {0}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Napomena : {0}
 ,Delivery Note Trends,Trendovi otpremnica
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Ovonedeljnom Pregled
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +20,In Stock Qty,Na skladištu Količina
+DocType: Delivery Trip,Calculate Estimated Arrival Times,Izračunajte procenjene vremenske prilike
 apps/erpnext/erpnext/accounts/general_ledger.py +111,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: GL Entry,Party,Stranka
@@ -4311,59 +4604,68 @@
 DocType: Sales Order,Delivery Date,Datum isporuke
 DocType: Opportunity,Opportunity Date,Datum prilike
 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: School 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."
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +99,Piecework,rad plaćen na akord
+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."
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,rad plaćen na akord
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Buying Rate,Prosj. Buying Rate
 DocType: Task,Actual Time (in Hours),Stvarno vrijeme (u satima)
 DocType: Employee,History In Company,Povijest tvrtke
 apps/erpnext/erpnext/config/learn.py +107,Newsletters,Newsletteri
 DocType: Drug Prescription,Description/Strength,Opis / snaga
 DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Stupanje
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +82,Same item has been entered multiple times,Isto artikal je ušao više puta
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Isto artikal je ušao više puta
 DocType: Department,Leave Block List,Ostavite Block List
-DocType: Sales Invoice,Tax ID,Porez ID
+DocType: Purchase Invoice,Tax ID,Porez ID
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,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/healthcare/doctype/lab_test/lab_test.js +38,Approve,odobriti
-apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +149,No Result to submit,Nije rezultat koji se šalje
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,odobriti
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +51,"Malformatted address for {0}, please fix to continue.","Malformatirana adresa za {0}, popravite za nastavak."
+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: Employee 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;"
 DocType: Opportunity,To Discuss,Za diskusiju
-apps/erpnext/erpnext/stock/stock_ledger.py +368,{0} units of {1} needed in {2} to complete this transaction.,{0} jedinicama {1} potrebno {2} za završetak ove transakcije.
+apps/erpnext/erpnext/stock/stock_ledger.py +375,{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
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Privremeni računi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +203,Black,Crn
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Crn
 DocType: BOM Explosion Item,BOM Explosion Item,BOM eksplozije artikla
 DocType: Account,Auditor,Revizor
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} artikala proizvedenih
 apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Nauči više
 DocType: Cheque Print Template,Distance from top edge,Udaljenost od gornje ivice
-apps/erpnext/erpnext/stock/get_item_details.py +317,Price List {0} is disabled or does not exist,Popis Cijena {0} je isključena ili ne postoji
+apps/erpnext/erpnext/stock/get_item_details.py +360,Price List {0} is disabled or does not exist,Popis Cijena {0} je isključena ili ne postoji
 DocType: Purchase Invoice,Return,Povratak
 DocType: Production Order Operation,Production Order Operation,Proizvodnja Order Operation
 DocType: Pricing Rule,Disable,Ugasiti
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +161,Mode of payment is required to make a payment,Način plaćanja je potrebno izvršiti uplatu
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,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."
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Imenovanja i konsultacije
-apps/erpnext/erpnext/schools/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/accounts/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} ne može biti ukinuta, jer je već {1}"
+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 +113,"Asset {0} cannot be scrapped, as it is already {1}","Asset {0} ne može biti ukinuta, jer je već {1}"
 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
+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 +140,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 +575,Sales Order {0} is not submitted,Prodajnog naloga {0} nije podnesen
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +579,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 +199,Fleet Management,Fleet Management
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +939,Add items from,Dodaj stavke iz
+apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Fleet Management
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +964,Add items from,Dodaj stavke iz
+apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Crop &amp; Lands
 DocType: Cheque Print Template,Regular,redovan
-apps/erpnext/erpnext/schools/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Ukupno weightage svih Kriteriji ocjenjivanja mora biti 100%
+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
@@ -4373,29 +4675,33 @@
 DocType: Training Event,Contact Number,Kontakt broj
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Skladište {0} ne postoji
 DocType: Monthly Distribution,Monthly Distribution Percentages,Mjesečni Distribucija Procenat
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +37,The selected item cannot have Batch,Izabrana stavka ne može imati Batch
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +38,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: Training Event,Has Certificate,Ima sertifikat
+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
 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 +137,Explore Sales Cycle,Istražite kola prodaje
+apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Istražite kola prodaje
 DocType: Assessment Plan,Supervisor,nadzornik
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +73,Online,online
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +70,Online,online
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +867,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
 DocType: Assessment Result Tool,Assessment Result Tool,Procjena Alat Rezultat
 DocType: BOM Scrap Item,BOM Scrap Item,BOM otpad Stavka
-apps/erpnext/erpnext/accounts/page/pos/pos.js +871,Submitted orders can not be deleted,Dostavljeni nalozi se ne može izbrisati
-apps/erpnext/erpnext/accounts/doctype/account/account.py +117,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Stanje računa već u zaduženje, ne smiju postaviti 'ravnoteža se mora' kao 'kreditne'"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +114,Quality Management,upravljanja kvalitetom
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +41,Item {0} has been disabled,Stavka {0} je onemogućena
+apps/erpnext/erpnext/accounts/page/pos/pos.js +886,Submitted orders can not be deleted,Dostavljeni nalozi se ne može izbrisati
+apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","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 +118,Quality Management,upravljanja kvalitetom
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,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: Employee Loan,Repay Fixed Amount per Period,Otplatiti fiksni iznos po periodu
 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 +78,Credit Note Amt,Kredit Napomena Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Credit Note Amt,Kredit Napomena Amt
 DocType: Employee External Work History,Employee External Work History,Istorija rada zaposlenog izvan preduzeća
-DocType: Tax Rule,Purchase,Kupiti
+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
 DocType: Item Group,Parent Item Group,Roditelj artikla Grupa
@@ -4403,23 +4709,25 @@
 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 +35,Cost Centers,Troška
+DocType: Land Unit,Linked Plant Analysis,Analiza povezanih biljaka
 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
 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: Training Event Employee,Invited,pozvan
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Više aktivnih Plaća Strukture nađeni za zaposlenog {0} za navedeni datumi
-apps/erpnext/erpnext/config/accounts.py +316,Setup Gateway accounts.,Podešavanje Gateway račune.
+apps/erpnext/erpnext/config/accounts.py +308,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 +42,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
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Period aplikacija ne može biti na dva alocation Records
+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 Group,Default Expense Account,Zadani račun rashoda
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student-mail ID
+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: Tax Rule,Sales Tax Template,Porez na promet Template
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2448,Select items to save the invoice,Odaberite stavke za spremanje fakture
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2467,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
@@ -4429,6 +4737,7 @@
 DocType: Academic Term,Term Start Date,Term Ozljede Datum
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,opp Count
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +242,Please find attached {0} #{1},U prilogu {0} {1} #
+apps/erpnext/erpnext/controllers/accounts_controller.py +701,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
 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
@@ -4442,6 +4751,7 @@
 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
 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.
@@ -4453,53 +4763,57 @@
 apps/erpnext/erpnext/config/support.py +22,Warranty,garancija
 DocType: Purchase Invoice,Debit Note Issued,Debit Napomena Zadani
 DocType: Production Order,Warehouses,Skladišta
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} imovine ne može se prenositi
-apps/erpnext/erpnext/stock/doctype/item/item.js +66,This Item is a Variant of {0} (Template).,Ovaj artikal je varijanta {0} (Template).
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} imovine ne može se prenositi
+apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Ovaj artikal je varijanta {0} (Template).
 DocType: Workstation,per hour,na sat
 apps/erpnext/erpnext/config/buying.py +7,Purchasing,Nabava
 DocType: Announcement,Announcement,objava
-DocType: School 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.
+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 +51,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 ."
-DocType: Company,Distribution,Distribucija
+apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Distribucija
+DocType: Expense Claim Advance,Expense Claim Advance,Advance Expense Claim
 DocType: Lab Test,Report Preference,Prednost prijave
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +129,Project Manager,Menadzer projekata
+apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Volonterske informacije.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,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/install_fixtures.py +110,Dispatch,Otpremanje
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Otpremanje
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,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 +173,Net Asset value as on,Neto vrijednost imovine kao i na
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Neto vrijednost imovine kao i na
+DocType: Crop,Produce,Proizvesti
 DocType: Account,Receivable,potraživanja
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +288,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Nije dozvoljeno da se promijeniti dobavljača kao narudžbenicu već postoji
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Nije dozvoljeno da se promijeniti dobavljača kao narudžbenicu već postoji
 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 +929,Select Items to Manufacture,Odaberi stavke za proizvodnju
-apps/erpnext/erpnext/accounts/page/pos/pos.js +939,"Master data syncing, it might take some time","Master podataka sinhronizaciju, to bi moglo da potraje"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +978,Select Items to Manufacture,Odaberi stavke za proizvodnju
+DocType: Delivery Stop,Delivery Stop,Dostava Stop
+apps/erpnext/erpnext/accounts/page/pos/pos.js +954,"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
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +40,View Salary Slips,Pogledajte ploče za plate
 DocType: Item Price,Item Price,Cijena artikla
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +48,Soap & Detergent,Sapun i deterdžent
+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/schools/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/setup/setup_wizard/industry_type.py +36,Motion Picture & Video,Motion Picture & Video
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Od vremena ne može biti veća nego vremena.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +74,Do you want to notify all the customers by email?,Želite li obavijestiti sve kupce putem e-pošte?
+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/accounts/doctype/subscription/subscription.js +51,Resume,Nastavi
-DocType: Item Variant Settings,If enabled then system will not update the fields of variants from the template but will copy the data of below mentioned fields while making new variant,"Ako je omogućeno, sistem neće ažurirati polja varijanti iz šablona, ali će kopirati podatke iz dolje navedenih polja dok pravite novu varijantu"
 DocType: Salary Detail,Component,sastavni
 DocType: Assessment Criteria,Assessment Criteria Group,Kriteriji procjene Group
 DocType: Healthcare Settings,Patient Name By,Ime pacijenta
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Otvaranje Ispravka vrijednosti mora biti manji od jednak {0}
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,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
 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: Item Variant Settings,Do not Update Variants,Ne ažurirajte varijante
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Podrska za Analitiku
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +142,Uncheck all,Poništi sve
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Poništi sve
 DocType: POS Profile,Terms and Conditions,Odredbe i uvjeti
 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 +202,Cannot cancel because submitted Stock Entry {0} exists,"Ne mogu otkazati , jer podnijela Stock Stupanje {0} postoji"
+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: Employee Loan,Disbursement Date,datuma isplate
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&#39;Primaoci&#39; nisu navedeni
 DocType: BOM Update Tool,Update latest price in all BOMs,Ažurirajte najnoviju cenu u svim BOM
@@ -4508,43 +4822,52 @@
 DocType: Purchase Invoice,In Words,Riječima
 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 +217,Today is {0}'s birthday!,Danas je {0} 's rođendan!
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Danas je {0} 's rođendan!
 DocType: Production Planning Tool,Material Request For Warehouse,Materijal Zahtjev za galeriju
 DocType: Sales Order Item,For Production,Za proizvodnju
 DocType: Payment Request,payment_url,payment_url
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +163,Please add a Temporary Opening account in Chart of Accounts,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: Material Request,MREQ-,MREQ-
+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 +356,Amount {0} {1} transferred from {2} to {3},Broj {0} {1} je prešao iz {2} u {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} transferred from {2} to {3},Broj {0} {1} je prešao iz {2} u {3}
 DocType: Sales Invoice,Get Advances Received,Kreiraj avansno primanje
 DocType: Email Digest,Add/Remove Recipients,Dodaj / ukloni primaoce
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +461,Transaction not allowed against stopped Production Order {0},Transakcija nije dopuštena protiv zaustavljena proizvodnja Reda {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +486,Transaction not allowed against stopped Production Order {0},Transakcija nije dopuštena protiv zaustavljena proizvodnja Reda {0}
 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/projects/doctype/project/project.py +205,Join,pristupiti
+apps/erpnext/erpnext/projects/doctype/project/project.py +216,Join,pristupiti
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Nedostatak Qty
-apps/erpnext/erpnext/stock/doctype/item/item.py +699,Item variant {0} exists with same attributes,Stavka varijanta {0} postoji sa istim atributima
+apps/erpnext/erpnext/stock/doctype/item/item.py +645,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Ne mogu promijeniti svojstva varijante nakon transakcije. Za to ćete morati napraviti novu stavku.
+apps/erpnext/erpnext/stock/doctype/item/item.py +685,Item variant {0} exists with same attributes,Stavka varijanta {0} postoji sa istim atributima
 DocType: Employee Loan,Repay from Salary,Otplatiti iz Plata
 DocType: Leave Application,LAP/,LAP /
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},Tražeći isplatu protiv {0} {1} za iznos {2}
 DocType: Salary Slip,Salary Slip,Plaća proklizavanja
 DocType: Lead,Lost Quotation,Lost Ponuda
-apps/erpnext/erpnext/utilities/user_progress.py +200,Student Batches,Studentske grupe
+apps/erpnext/erpnext/utilities/user_progress.py +218,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."
 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: Salary Slip,Total Interest Amount,Ukupan iznos kamate
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,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: 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."
 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 +48,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 +965,It is needed to fetch Item Details.,Potrebno je da se donese Stavka Detalji.
+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
+DocType: Land Unit,Parent Land Unit,Roditeljska jedinica
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1045,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: Account,Account,Konto
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Serijski Ne {0} već je primila
@@ -4552,40 +4875,45 @@
 DocType: Expense Claim,Vehicle Log,vozilo se Prijavite
 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 +1326,Delete permanently?,Obrisati trajno?
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1341,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.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Invalid {0}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Sick Leave,Bolovanje
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,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/industry_type.py +22,Department Stores,Robne kuće
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Robne kuće
 ,Item Delivery Date,Datum isporuke artikla
 DocType: Warehouse,PIN,PIN
-apps/erpnext/erpnext/setup/setup_wizard/sample_data.py +110,Setup your School in ERPNext,Podešavanje vaše škole u ERPNext
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +125,Error '{0}' occured. Arguments {1}.,Pojavila se greška &#39;{0}&#39;. Argumenti {1}.
 DocType: Sales Invoice,Base Change Amount (Company Currency),Base Promijeni Iznos (Company Valuta)
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Nema računovodstvene unosi za sljedeće skladišta
 apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Spremite dokument prvi.
+apps/erpnext/erpnext/shopping_cart/cart.py +71,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: Expense Claim Detail,Expense Date,Rashodi Datum
 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
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Last Order Iznos
+apps/erpnext/erpnext/stock/doctype/item/item.py +264," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} 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: Daily Work Summary,Email Sent To,E-mail poslat
+DocType: Delivery Stop,Email Sent To,E-mail poslat
 DocType: Budget,Warn,Upozoriti
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Da li ste sigurni da želite da se odjavite?
 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: BOM,Manufacturing User,Proizvodnja korisnika
+DocType: Asset Maintenance,Manufacturing User,Proizvodnja korisnika
 DocType: Purchase Invoice,Raw Materials Supplied,Sirovine nabavlja
 DocType: C-Form,Series,serija
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +270,Currency of the price list {0} must be {1} or {2},Valuta cenovnika {0} mora biti {1} ili {2}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +273,Currency of the price list {0} must be {1} or {2},Valuta cenovnika {0} mora biti {1} ili {2}
 DocType: Appraisal,Appraisal Template,Procjena Predložak
+DocType: Soil Texture,Ternary Plot,Ternary plot
 DocType: Item Group,Item Classification,Stavka Klasifikacija
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +127,Business Development Manager,Business Development Manager
+DocType: Driver,License Number,Broj licence
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,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: Drug Prescription,Period,Period
+DocType: Crop,Period,Period
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Glavna knjiga
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Zaposlenik {0} na odmoru na {1}
 apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Pogledaj potencijalne kupce
@@ -4593,9 +4921,9 @@
 DocType: Item Attribute Value,Attribute Value,Vrijednost atributa
 ,Itemwise Recommended Reorder Level,Itemwise Preporučio redoslijeda Level
 DocType: Salary Detail,Salary Detail,Plaća Detail
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1017,Please select {0} first,Odaberite {0} Prvi
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,Odaberite {0} Prvi
 DocType: Appointment Type,Physician,Lekar
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +804,Batch {0} of Item {1} has expired.,Batch {0} od {1} Stavka je istekla.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +833,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
 DocType: Sales Invoice,Commission,Provizija
 apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Time Sheet za proizvodnju.
@@ -4606,7 +4934,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Skladište nije pronađeno u sistemu
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,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 +24,`Freeze Stocks Older Than` should be smaller than %d days.,`blokiraj zalihe starije od podrazumijevanog manje od % d dana .
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`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 +45,Set a sales goal you'd like to achieve for your company.,Postavite cilj prodaje koji želite ostvariti za svoju kompaniju.
 ,Project wise Stock Tracking,Supervizor pracenje zaliha
@@ -4614,42 +4942,50 @@
 apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratorija
 DocType: Stock Entry Detail,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 +66,Customer Group is Required in POS Profile,Korisnička grupa je potrebna u POS profilu
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +71,Customer Group is Required in POS Profile,Korisnička grupa je potrebna u POS profilu
 apps/erpnext/erpnext/config/hr.py +12,Employee records.,Zaposlenih evidencija.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +92,Please set Next Depreciation Date,Molimo podesite Sljedeća Amortizacija Datum
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +92,Please set Next Depreciation Date,Molimo podesite Sljedeća Amortizacija Datum
 DocType: HR Settings,Payroll Settings,Postavke plaće
-apps/erpnext/erpnext/config/accounts.py +154,Match non-linked Invoices and Payments.,Klađenje na ne-povezane faktura i plaćanja.
+apps/erpnext/erpnext/config/accounts.py +146,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 +24,Root cannot have a parent cost center,Korijen ne mogu imati središte troškova roditelj
 apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Odaberite Marka ...
+apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Neprofitna (beta)
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Treninga / Rezultati
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Accumulated Depreciation as on,Ispravka vrijednosti kao na
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Ispravka vrijednosti kao na
 DocType: Sales Invoice,C-Form Applicable,C-obrascu
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +399,Operation Time must be greater than 0 for Operation {0},Vrijeme rada mora biti veći od 0 za rad {0}
+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}
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Skladište je obavezno
 DocType: Supplier,Address and Contacts,Adresa i kontakti
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,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 +922,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 +387,Production Order cannot be raised against a Item Template,Proizvodnja Nalog ne može biti podignuta protiv Item Template
+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
 DocType: Bank Guarantee,Start Date,Datum početka
 apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Dodijeli odsustva za period.
 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 +50,Account {0}: You can not assign itself as parent account,Konto {0}: Ne može se označiti kao nadređeni konto samom sebi
+apps/erpnext/erpnext/accounts/doctype/account/account.py +46,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
 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: Sample Collection,Collected By,Prikupljeno od strane
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,procjena rezultata
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,procjena rezultata
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Sati
 DocType: Project,Expected Start Date,Očekivani datum početka
+apps/erpnext/erpnext/stock/doctype/item/item.js +60,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 +18,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/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 +34,Transaction currency must be same as Payment Gateway currency,Transakcija valuta mora biti isti kao i Payment Gateway valutu
 DocType: Payment Entry,Receive,Primiti
 apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Citati:
@@ -4659,20 +4995,20 @@
 DocType: Workstation,Operating Costs,Operativni troškovi
 DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Akcija ako Akumulirani Mjesečni budžet Exceeded
 DocType: Subscription,Submit on creation,Dostavi na stvaranju
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +469,Currency for {0} must be {1},Valuta za {0} mora biti {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +470,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 +508,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/stock/doctype/item/item.py +485,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/hr/doctype/training_event/training_event.js +16,Training Feedback,trening Feedback
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +458,Production Order {0} must be submitted,Proizvodnja Red {0} mora biti podnesen
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +483,Production Order {0} must be submitted,Proizvodnja Red {0} mora biti podnesen
 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}
-apps/erpnext/erpnext/schools/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/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
-apps/erpnext/erpnext/stock/doctype/item/item.js +272,Add / Edit Prices,Dodaj / Uredi cijene
+apps/erpnext/erpnext/stock/doctype/item/item.js +268,Add / Edit Prices,Dodaj / Uredi cijene
 DocType: Batch,Parent Batch,roditelja Batch
 DocType: Cheque Print Template,Cheque Print Template,Ček Ispis Template
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Grafikon troškovnih centara
@@ -4681,7 +5017,6 @@
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +655,My Orders,Moje narudžbe
 DocType: Price List,Price List Name,Cjenik Ime
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Svakodnevni rad Pregled za {0}
-DocType: Employee Loan,Totals,Ukupan rezultat
 DocType: BOM,Manufacturing,Proizvodnja
 ,Ordered Items To Be Delivered,Naručeni proizvodi za dostavu
 DocType: Account,Income,Prihod
@@ -4691,127 +5026,140 @@
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,Prodajni računi {0} su već potvrđeni
 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
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Završetak Datum
+DocType: Asset Maintenance Log,Completion Date,Završetak Datum
 DocType: Purchase Invoice Item,Amount (Company Currency),Iznos (valuta preduzeća)
+DocType: Crop,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 +372,{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.
+apps/erpnext/erpnext/stock/stock_ledger.py +379,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} 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/config/hr.py +233,Organization unit (department) master.,Organizacija jedinica ( odjela ) majstor .
-apps/erpnext/erpnext/utilities/user_progress.py +218,Go to Rooms,Idite u Sobe
+apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Organizacija jedinica ( odjela ) majstor .
+DocType: Shipping Rule,Shipping Rule Type,Tip pravila isporuke
+apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Idite u Sobe
 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: Email Digest,Pending Quotations,U očekivanju Citati
-apps/erpnext/erpnext/config/accounts.py +326,Point-of-Sale Profile,Point-of-prodaju profil
+apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-of-prodaju profil
 apps/erpnext/erpnext/config/healthcare.py +153,Lab Test Configurations.,Konfiguracije laboratorijskih testova.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,unsecured krediti
 DocType: Cost Center,Cost Center Name,Troška Name
-DocType: Employee,B+,B +
+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 +77,Total Paid Amt,Ukupno Paid Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +88,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
 DocType: Hub Settings,Company and Seller Profile,Profil firme i prodavca
 ,GST Itemised Sales Register,PDV Specificirane prodaje Registracija
+DocType: Soil Texture,Silt Loam,Silt Loam
 ,Serial No Service Contract Expiry,Serijski Bez isteka Ugovor o pružanju usluga
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Ne možete kreditnim i debitnim isti račun u isto vrijeme
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +297,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}
-apps/erpnext/erpnext/utilities/user_progress.py +88,Your Suppliers,Vaši dobavljači
+apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,Vaši dobavljači
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Molim vas ispravite
 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 +365,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/accounts/doctype/payment_entry/payment_entry.py +363,Received From,Dobili od
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,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/accounts/doctype/payment_entry/payment_entry.py +364,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/hr/doctype/expense_claim/expense_claim.py +24,{0}: From {0} for {1},{0}: Od {0} {1} za
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +219,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","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 +166,Row #{0}: Set Supplier for item {1},Row # {0}: Set dobavljač za stavku {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","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 +167,Row #{0}: Set Supplier for item {1},Row # {0}: Set dobavljač za stavku {1}
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,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 +183,Website Image {0} attached to Item {1} cannot be found,Sajt Slika {0} prilogu Stavka {1} ne može biti pronađena
+apps/erpnext/erpnext/stock/doctype/item/item.py +185,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
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,Računar
+DocType: Asset,Assets,Imovina
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Računar
 DocType: Item,List this Item in multiple groups on the website.,Popis ovaj predmet u više grupa na web stranici.
-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/journal_entry/journal_entry.py +323,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
+DocType: Payment Term,Due Date Based On,Due Date Based On
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,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 +203,{0} {1} does not exist,{0} {1} ne postoji
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +321,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 +85,Item: {0} does not exist in the system,Detaljnije: {0} ne postoji u sustavu
-apps/erpnext/erpnext/accounts/doctype/account/account.py +109,You are not authorized to set Frozen value,Niste ovlašteni za postavljanje Frozen vrijednost
+apps/erpnext/erpnext/accounts/doctype/account/account.py +108,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
 DocType: Payment Reconciliation,From Invoice Date,Iz Datum računa
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +28,You don't have permission to submit,Nemate dozvolu za slanje
-apps/erpnext/erpnext/accounts/party.py +268,Billing currency must be equal to either default comapany's currency or party account currency,Billing valuti mora biti jednak ili default comapany valuta ili stranka račun valuti
 DocType: Healthcare Settings,Laboratory Settings,Laboratorijske postavke
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +71,Leave Encashment,Ostavite unovčenja
-apps/erpnext/erpnext/public/js/setup_wizard.js +111,What does it do?,Što učiniti ?
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +75,To Warehouse,Za skladište
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +26,All Student Admissions,Svi Student Prijemni
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Ostavite unovčenja
+apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Što učiniti ?
+DocType: Crop,Byproducts,Podbrojevi
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +76,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
-apps/erpnext/erpnext/stock/doctype/item/item.py +418,'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/stock/doctype/item/item.py +434,'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 +62,Select Status,Izaberite Status
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Gledatelji ne može biti označena za budući datum
 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: Purchase Taxes and Charges,Account Head,Zaglavlje konta
-apps/erpnext/erpnext/config/stock.py +173,Update additional costs to calculate landed cost of items,Update dodatne troškove za izračun troškova spustio stavki
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +149,Electrical,Električna
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,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)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Red {0}: kursa obavezna
+DocType: Grant Application,Requested Amount,Traženi iznos
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +346,Row {0}: Exchange Rate is mandatory,Red {0}: kursa obavezna
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,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 +216,Birthday Reminder for {0},Rođendan Podsjetnik za {0}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,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 +355,Debit To account must be a Balance Sheet account,Zaduženja na račun mora biti bilans stanja računa
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +359,Debit To account must be a Balance Sheet account,Zaduženja na račun mora biti bilans stanja računa
 DocType: Buying Settings,Naming Series,Imenovanje serije
 DocType: Leave Block List,Leave Block List Name,Ostavite popis imena Block
 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
-apps/erpnext/erpnext/schools/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in School &gt; School Settings,Molimo vas da postavite sistem imenovanja instruktora u školi&gt; Postavke škole
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,dionicama u vrijednosti
 DocType: Timesheet,Production Detail,proizvodnja Detail
 DocType: Restaurant,Active Menu,Aktivni meni
 DocType: Target Detail,Target Qty,Ciljana Kol
 DocType: Shopping Cart Settings,Checkout Settings,Plaćanje Postavke
-DocType: Attendance,Present,Sadašnje
+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 +325,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: Sales Order Item,Ordered Qty,Naručena kol
-apps/erpnext/erpnext/stock/doctype/item/item.py +727,Item {0} is disabled,Stavka {0} je onemogućeno
+apps/erpnext/erpnext/stock/doctype/item/item.py +713,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 +904,BOM does not contain any stock item,BOM ne sadrži nikakve zaliha stavka
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +929,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/config/projects.py +19,Project activity / task.,Projektna aktivnost / zadatak.
 DocType: Vehicle Log,Refuelling Details,Dopuna goriva Detalji
 apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Generiranje plaće gaćice
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"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
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +171,Select Delivery Notes,Izaberite Napomene o dostavi
 DocType: Purchase Invoice,Write Off Amount (Company Currency),Otpis Iznos (poduzeća Valuta)
 DocType: Sales Invoice Timesheet,Billing Hours,Billing Hours
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +500,Default BOM for {0} not found,Uobičajeno sastavnice za {0} nije pronađen
-apps/erpnext/erpnext/stock/doctype/item/item.py +498,Row #{0}: Please set reorder quantity,Row # {0}: Molimo set Ponovno redj količinu
+DocType: Project,Total Sales Amount (via Sales Order),Ukupan iznos prodaje (preko prodajnog naloga)
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +528,Default BOM for {0} not found,Uobičajeno sastavnice za {0} nije pronađen
+apps/erpnext/erpnext/stock/doctype/item/item.py +489,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: 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/schools/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} je neaktivan student
+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: Offer Letter,Offer Letter Terms,Ponuda Pismo Uvjeti
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,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: Employee External Work History,Salary,Plata
 DocType: Serial No,Delivery Document Type,Dokument isporuke - tip
-DocType: Process Payroll,Submit all salary slips for the above selected criteria,Slanje sve plaće gaćice za gore odabranih kriterija
 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.
@@ -4822,24 +5170,27 @@
 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 +94,Please mention the Lead Name in Lead {0},Molim vas da navedete Lead Lead u Lead-u {0}
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +108,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 +319,BOM and Manufacturing Quantity are required,BOM i proizvodnja Količina su potrebne
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +535,BOM and Manufacturing Quantity are required,BOM i proizvodnja Količina su potrebne
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,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
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +67,No Delivery Note selected for Customer {},Nije odabrana beleška za isporuku za kupca {}
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,BOM zamijenjeno
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +992,Select Items based on Delivery Date,Izaberite stavke na osnovu datuma isporuke
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,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 +119,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/schools/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 +103,Please enter default currency in Company Master,Unesite zadanu valutu u tvrtki Master
+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 +106,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 +109,Daily Reminders,Dnevni podsjetnik
 DocType: Products Settings,Home Page is Products,Početna stranica su proizvodi
@@ -4848,17 +5199,17 @@
 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
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +111,Customer Service,Služba za korisnike
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Služba za korisnike
 DocType: BOM,Thumbnail,Thumbnail
 DocType: Item Customer Detail,Item Customer Detail,Artikal - detalji kupca
 apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Ponuda kandidata posao.
 DocType: Notification Control,Prompt for Email on Submission of,Pitaj za e-poštu na podnošenje
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Ukupno izdvojene Listovi su više od nekoliko dana u razdoblju
+DocType: Land Unit,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/config/accounts.py +296,Default settings for accounting transactions.,Zadane postavke za računovodstvene poslove.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +23,Please setup Employee Naming System in Human Resource &gt; HR Settings,Molimo da podesite sistem imenovanja zaposlenih u ljudskim resursima&gt; HR Settings
+apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Zadane postavke za računovodstvene poslove.
 DocType: Maintenance Visit,MV,MV
 DocType: Restaurant,Default Tax Template,Podrazumevani obrazac poreza
 DocType: Fees,Student Details,Student Detalji
@@ -4871,11 +5222,11 @@
 DocType: Sales Order,Printing Details,Printing Detalji
 DocType: Task,Closing Date,Datum zatvaranja
 DocType: Sales Order Item,Produced Quantity,Proizvedena količina
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +122,Engineer,inženjer
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,inženjer
 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 +168,Item Code required at Row No {0},Kod artikla je potreban u redu broj {0}
-apps/erpnext/erpnext/utilities/user_progress.py +133,Go to Items,Idi na stavke
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Kod artikla je potreban u redu broj {0}
+apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Idi na stavke
 DocType: Sales Partner,Partner Type,Partner Tip
 DocType: Purchase Taxes and Charges,Actual,Stvaran
 DocType: Restaurant Menu,Restaurant Manager,Restoran menadžer
@@ -4892,35 +5243,37 @@
 DocType: Item Reorder,Re-Order Level,Re-order Level
 DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Unesite stavke i planirani Količina za koje želite povećati proizvodne naloge ili preuzimanje sirovine za analizu.
 apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Gantogram
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +95,Part-time,Part - time
+DocType: Crop Cycle,Cycle Type,Tip ciklusa
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,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 +59,Series Updated,Serija Updated
-apps/erpnext/erpnext/accounts/doctype/account/account.py +162,Report Type is mandatory,Vrsta izvjestaja je obavezna
+apps/erpnext/erpnext/accounts/doctype/account/account.py +161,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/industry_type.py +45,Retail & Wholesale,Trgovina na veliko i
+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}
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Razmak Datum ažurira
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +131,Split Batch,Split Batch
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +138,Split Batch,Split Batch
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Uspješno Pomirio
 DocType: Request for Quotation Supplier,Download PDF,Preuzmi PDF
 DocType: Production Order,Planned End Date,Planirani Završni datum
-apps/erpnext/erpnext/controllers/buying_controller.py +423,Please enter Schedule Date,Molimo unesite datum rasporeda
-apps/erpnext/erpnext/config/stock.py +189,Where items are stored.,Gdje predmeti su pohranjeni.
+apps/erpnext/erpnext/controllers/buying_controller.py +424,Please enter Schedule Date,Molimo unesite datum rasporeda
+apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informacije o donatoru.
 DocType: Request for Quotation,Supplier Detail,dobavljač Detail
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Greška u formuli ili stanja: {0}
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,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%
-DocType: Attendance,Attendance,Pohađanje
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Pohađanje
 apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,Stock Predmeti
 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/accounts/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Izvor i Target skladište ne može biti isto
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +535,Posting date and posting time is mandatory,Datum knjiženja i knjiženje vrijeme je obvezna
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +103,Creating {0},Kreiranje {0}
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Izvor i Target skladište ne može biti isto
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +561,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
 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.
@@ -4930,39 +5283,42 @@
 apps/erpnext/erpnext/config/selling.py +67,Price List master.,Cjenik majstor .
 DocType: Task,Review Date,Datum pregleda
 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
 DocType: Purchase Taxes and Charges,On Net Total,Na Net Total
 apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Vrijednost za Atributi {0} mora biti u rasponu od {1} na {2} u koracima od {3} za Stavka {4}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,Target warehouse in row {0} must be same as Production Order,Target skladište u redu {0} mora biti ista kao Production Order
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +166,Target warehouse in row {0} must be same as Production Order,Target skladište u redu {0} mora biti ista kao Production Order
 DocType: Restaurant Reservation,Waitlisted,Waitlisted
-apps/erpnext/erpnext/accounts/doctype/account/account.py +127,Currency can not be changed after making entries using some other currency,Valuta ne mogu se mijenjati nakon što unose preko neke druge valute
+apps/erpnext/erpnext/accounts/doctype/account/account.py +126,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 +93,Administrative Expenses,Administrativni troškovi
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,savjetodavni
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,savjetodavni
 DocType: Customer Group,Parent Customer Group,Roditelj Kupac Grupa
 DocType: Journal Entry,Subscription,Pretplata
 DocType: Purchase Invoice,Contact Email,Kontakt email
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Čekanje stvaranja naknade
+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/install_fixtures.py +229,Notice Period,Otkazni rok
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,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: Asset Maintenance Task,Preventive Maintenance,Preventivno održavanje
 DocType: Delivery Note Item,Against Sales Invoice,Protiv prodaje fakture
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +141,Please enter serial numbers for serialized item ,Unesite serijski brojevi za serijalizovanoj stavku
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,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 +493,Credit Account,Kreditni račun
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +501,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 +57,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
-apps/erpnext/erpnext/stock/doctype/item/item.py +694,Please specify Attribute Value for attribute {0},Molimo navedite vrijednost atributa za atribut {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +680,Please specify Attribute Value for attribute {0},Molimo navedite vrijednost atributa za atribut {0}
 DocType: Item,Default Warehouse,Glavno skladište
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Budžet se ne može dodijeliti protiv grupe računa {0}
 DocType: Healthcare Settings,Patient Registration,Registracija pacijenata
@@ -4974,23 +5330,27 @@
 DocType: Appraisal,Total Score (Out of 5),Ukupna ocjena (od 5)
 DocType: Fee Structure,FS.,FS.
 DocType: Student Attendance Tool,Batch,Serija
+DocType: Donor,Donor Type,Tip donatora
 apps/erpnext/erpnext/stock/doctype/item/item.js +27,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: Room,Seating Capacity,Broj sjedećih mjesta
 DocType: Issue,ISS-,ISS-
 DocType: Lab Test Groups,Lab Test Groups,Laboratorijske grupe
 DocType: Project,Total Expense Claim (via Expense Claims),Ukupni rashodi potraživanja (preko rashodi potraživanja)
 DocType: GST Settings,GST Summary,PDV Pregled
 DocType: Assessment Result,Total Score,Ukupni rezultat
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +116,Please set the Default Cost Center in {0} company,Molimo da podesite Centar za podrazumevane troškove u kompaniji {0}
 DocType: Journal Entry,Debit Note,Rashodi - napomena
 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: 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: Journal Entry,Total Debit,Ukupno zaduženje
 DocType: Manufacturing Settings,Default Finished Goods Warehouse,Uobičajeno Gotovi proizvodi skladište
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +77,Sales Person,Referent prodaje
-apps/erpnext/erpnext/config/accounts.py +241,Budget and Cost Center,Budžet i troškova Center
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +60,Multiple default mode of payment is not allowed,Višestruki način plaćanja nije dozvoljen
+apps/erpnext/erpnext/config/accounts.py +233,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
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,za
 ,Appointment Analytics,Imenovanje analitike
 DocType: Vehicle Service,Half Yearly,Polu godišnji
@@ -4999,17 +5359,18 @@
 DocType: Healthcare Settings,Consultations in valid days,Konsultacije u važećim danima
 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 .
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Grupa Roll Ne
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Kreiranje Fee-a nije uspelo
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Grupa Roll Ne
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Kreiranje Fee-a nije uspelo
 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"
 DocType: Purchase Invoice,Total Advance,Ukupno predujma
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Promijenite šablon kod
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Termin Završni datum ne može biti ranije od termina Ozljede Datum. Molimo ispravite datume i pokušajte ponovo.
+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
 ,BOM Stock Report,BOM Stock Report
 DocType: Stock Reconciliation Item,Quantity Difference,Količina Razlika
-apps/erpnext/erpnext/config/hr.py +315,Processing Payroll,Obrada Payroll
+DocType: Employee Advance,EA-,EA-
+apps/erpnext/erpnext/config/hr.py +320,Processing Payroll,Obrada Payroll
 DocType: Opportunity Item,Basic Rate,Osnovna stopa
 DocType: GL Entry,Credit Amount,Iznos kredita
 DocType: Cheque Print Template,Signatory Position,potpisnik Pozicija
@@ -5017,7 +5378,7 @@
 DocType: Timesheet,Total Billable Hours,Ukupno naplative Hours
 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
-DocType: Supplier,Credit Days Based On,Credit Dani Na osnovu
+DocType: Company,Credit Days Based On,Credit Dani Na osnovu
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Red {0}: Raspoređeni iznos {1} mora biti manji od ili jednak iznos plaćanja Entry {2}
 ,Course wise Assessment Report,Naravno mudar Izvještaj o procjeni
 DocType: Tax Rule,Tax Rule,Porez pravilo
@@ -5025,66 +5386,73 @@
 DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planirajte vrijeme za rezanje izvan Workstation Radno vrijeme.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +92,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} nema raspored lekara. Dodajte ga u majstora lekara
 apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Kupci u Queue
+DocType: Driver,Issuing Date,Datum izdavanja
 DocType: Student,Nationality,državljanstvo
 ,Items To Be Requested,Potraživani artikli
 DocType: Company,Company Info,Podaci o preduzeću
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1359,Select or add new customer,Odaberite ili dodati novi kupac
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +154,Cost center is required to book an expense claim,Troška je potrebno rezervirati trošak tvrdnju
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1374,Select or add new customer,Odaberite ili dodati novi kupac
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +179,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
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Obeležite prisustvo
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +487,Debit Account,Zaduži račun
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Obeležite prisustvo
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +495,Debit Account,Zaduži račun
 DocType: Fiscal Year,Year Start Date,Početni datum u godini
 DocType: Attendance,Employee Name,Ime i prezime radnika
 DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Restoran za unos stavke
-DocType: Sales Invoice,Rounded Total (Company Currency),Zaobljeni Ukupno (Društvo valuta)
-apps/erpnext/erpnext/accounts/doctype/account/account.py +99,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 +240,{0} {1} has been modified. Please refresh.,{0} {1} je izmijenjen . Osvježite stranicu.
+DocType: Purchase Invoice,Rounded Total (Company Currency),Zaobljeni Ukupno (Društvo valuta)
+apps/erpnext/erpnext/accounts/doctype/account/account.py +98,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 +260,{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.
+DocType: Asset Maintenance Team,Maintenance Team Members,Članovi tima za održavanje
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Kupovina Iznos
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Dobavljač Ponuda {0} stvorio
 apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Kraja godine ne može biti prije početka godine
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +222,Employee Benefits,Primanja zaposlenih
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Employee Benefits,Primanja zaposlenih
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,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: Production Order,Manufactured Qty,Proizvedeno Kol
 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
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,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/hr/doctype/employee/employee.py +242,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 +31,{0}: {1} does not exists,{0}: {1} ne postoji
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +75,Select Batch Numbers,Izaberite šarže
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Izaberite šarže
 apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Mjenice podignuta na kupce.
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID Projekta
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},No red {0}: Iznos ne može biti veći od čekanju Iznos protiv rashodi potraživanje {1}. Na čekanju iznos je {2}
-DocType: Maintenance Schedule,Schedule,Raspored
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +532,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},No red {0}: Iznos ne može biti veći od čekanju Iznos protiv rashodi potraživanje {1}. Na čekanju iznos je {2}
+DocType: Assessment Plan,Schedule,Raspored
 DocType: Account,Parent Account,Roditelj račun
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +253,Available,Dostupno
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,Dostupno
 DocType: Quality Inspection Reading,Reading 3,Čitanje 3
 ,Hub,Čvor
 DocType: GL Entry,Voucher Type,Bon Tip
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1691,Price List not found or disabled,Cjenik nije pronađena ili invaliditetom
-DocType: Lab Test,Approved,Odobreno
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1706,Price List not found or disabled,Cjenik nije pronađena ili invaliditetom
+DocType: Student Applicant,Approved,Odobreno
 DocType: Pricing Rule,Price,Cijena
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',Zaposlenik razriješen na {0} mora biti postavljen kao 'lijevo '
 DocType: Hub Settings,Last Sync On,Poslednja sinhronizacija uključena
 DocType: Guardian,Guardian,staratelj
 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: Employee,Education,Obrazovanje
+DocType: Academic Term,Education,Obrazovanje
 apps/erpnext/erpnext/public/js/pos/pos.html +78,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 +48,Monthly Sales Target (,Mesečna prodajna meta (
 apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modificirani
-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."
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"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"
+DocType: Asset Repair,Repair Status,Status popravke
 apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Računovodstvene stavke
 DocType: Delivery Note Item,Available Qty at From Warehouse,Dostupno Količina na Od Skladište
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,Molimo odaberite zaposlenih Record prvi.
 DocType: POS Profile,Account for Change Amount,Nalog za promjene Iznos
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,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}
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Šifra predmeta:
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +215,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: 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 +9,Course Code: ,Šifra predmeta:
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,Unesite trošak računa
 DocType: Account,Stock,Zaliha
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1042,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Referenca Vrsta dokumenta mora biti jedan od Narudžbenice, fakturi ili Journal Entry"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: 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
@@ -5095,53 +5463,52 @@
 DocType: Sales Invoice Item,Discount and Margin,Popust i Margin
 DocType: Lab Test,Prescription,Prescription
 DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,Povucite prodajne naloge (na čekanju za isporuku) na temelju navedenih kriterija
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +90,Not Available,nije dostupno
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,nije dostupno
 DocType: Pricing Rule,Min Qty,Min kol
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Onemogući šablon
-DocType: Asset Movement,Transaction Date,Transakcija Datum
+DocType: GL Entry,Transaction Date,Transakcija Datum
 DocType: Production Plan Item,Planned Qty,Planirani Kol
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Ukupno porez
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177,For Quantity (Manufactured Qty) is mandatory,Za Količina (Proizvedeno Qty) je obavezno
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +182,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)
-apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,The Year Završni datum ne može biti ranije od godine Ozljede Datum. Molimo ispravite datume i pokušajte ponovo.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Red {0}: Party Tip i stranka je primjenjiv samo protiv potraživanja / računa dobavljača
+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.
 DocType: Notification Control,Purchase Receipt Message,Poruka primke
 DocType: BOM,Scrap Items,Scrap Predmeti
 DocType: Production Order,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/stock.py +12,Record item movement.,Zabilježite stavku pokret.
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +57,Set default mode of payment,Podesi podrazumevani način plaćanja
+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: Hub Settings,Hub Settings,Hub Settings
 DocType: Project,Gross Margin %,Bruto marža %
 DocType: BOM,With Operations,Uz operacije
-apps/erpnext/erpnext/accounts/party.py +264,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Računovodstvo stavke su već učinjeni u valuti {0} {1} za firmu. Molimo odaberite potraživanja ili platiti račun s valutnom {0}.
+apps/erpnext/erpnext/accounts/party.py +262,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,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 Detail,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 +141,Fulfilment,Ispunjavanje
 DocType: Purchase Taxes and Charges,On Previous Row Amount,Na prethodnu Row visini
-DocType: Student,Home Address,Kućna adresa
 DocType: Item,Has Expiry Date,Ima datum isteka
-apps/erpnext/erpnext/config/stock.py +111,Item Variant Settings.,Postavke varijante postavki.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +249,Transfer Asset,Transfer imovine
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +269,Transfer Asset,Transfer imovine
 DocType: POS Profile,POS Profile,POS profil
 DocType: Training Event,Event Name,Naziv događaja
 DocType: Physician,Phone (Office),Telefon (Office)
-apps/erpnext/erpnext/hooks.py +147,Admission,upis
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +29,Admissions for {0},Priznanja za {0}
-apps/erpnext/erpnext/config/accounts.py +265,"Seasonality for setting budgets, targets etc.","Sezonski za postavljanje budžeta, ciljeva itd"
+apps/erpnext/erpnext/hooks.py +151,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 +257,"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 +147,"Item {0} is a template, please select one of its variants","Stavka {0} je predložak, odaberite jednu od njegovih varijanti"
+apps/erpnext/erpnext/stock/get_item_details.py +142,"Item {0} is a template, please select one of its variants","Stavka {0} je predložak, odaberite jednu od njegovih varijanti"
 DocType: Asset,Asset Category,Asset Kategorija
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Neto plaća ne može biti negativna
 DocType: Assessment Plan,Room,soba
 DocType: Purchase Order,Advance Paid,Advance Paid
 DocType: Item,Item Tax,Porez artikla
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +843,Material to Supplier,Materijal dobavljaču
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +384,Excise Invoice,Akcizama Račun
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Prag {0}% se pojavljuje više od jednom
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +868,Material to Supplier,Materijal dobavljaču
+DocType: Soil Texture,Loamy Sand,Loamy Sand
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +594,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 +138,Current Liabilities,Kratkoročne obveze
@@ -5149,16 +5516,17 @@
 DocType: Patient,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 +80,"{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."
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.","{0} 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
 DocType: Employee Loan,Loan Type,Vrsta kredita
 DocType: Scheduling Tool,Scheduling Tool,zakazivanje alata
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +176,Credit Card,kreditna kartica
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,kreditna kartica
 DocType: BOM,Item to be manufactured or repacked,Artikal će biti proizveden ili prepakiran
-apps/erpnext/erpnext/config/stock.py +184,Default settings for stock transactions.,Zadane postavke za burzovne transakcije.
 DocType: Employee Education,Major/Optional Subjects,Glavni / Izborni predmeti
 DocType: Sales Invoice Item,Drop Ship,Drop Ship
-DocType: Hub Settings,Suspended,Suspendirano
+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
@@ -5167,13 +5535,13 @@
 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: 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 +96,Please select the Company first,Molimo prvo odaberite Kompaniju
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,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 +52,Attach Logo,Priložiti logo
+apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Priložiti logo
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +43,Stock Levels,Stock Nivoi
 DocType: Customer,Commission Rate,Komisija Stopa
 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 +346,Make Variant,Make Variant
+apps/erpnext/erpnext/stock/doctype/item/item.js +472,Make Variant,Make Variant
 apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Blok ostaviti aplikacija odjelu.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +144,"Payment Type must be one of Receive, Pay and Internal Transfer","Plaćanje Tip mora biti jedan od Primi, Pay i unutrašnje Transfer"
 apps/erpnext/erpnext/config/selling.py +179,Analytics,analitika
@@ -5181,7 +5549,8 @@
 DocType: Vehicle,Model,model
 DocType: Production Order,Actual Operating Cost,Stvarni operativnih troškova
 DocType: Payment Entry,Cheque/Reference No,Ček / Reference Ne
-apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root cannot be edited.,Korijen ne može se mijenjati .
+DocType: Soil Texture,Clay Loam,Clay Loam
+apps/erpnext/erpnext/accounts/doctype/account/account.py +83,Root cannot be edited.,Korijen ne može se mijenjati .
 DocType: Item,Units of Measure,Jedinice mjere
 DocType: Manufacturing Settings,Allow Production on Holidays,Dopustite Production o praznicima
 DocType: Sales Order,Customer's Purchase Order Date,Kupca narudžbenice Datum
@@ -5194,39 +5563,37 @@
 DocType: Company,Existing Company,postojeći Company
 DocType: Healthcare Settings,Result Emailed,Rezultat poslat
 apps/erpnext/erpnext/controllers/buying_controller.py +84,"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/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/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Odaberite CSV datoteku
 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/templates/pages/home.html +14,Featured Products,Istaknuti Proizvodi
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +132,Designer,Imenovatelj
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,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 +487,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}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +491,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: Batch,Expiry Date,Datum isteka
+DocType: Driver,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 +351,Please select Category first,Molimo odaberite kategoriju prvi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,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 +209,"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: Global Defaults,Do not show any symbol like $ etc next to currencies.,Ne pokazati nikakav simbol poput $ iza valute.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +459, (Half Day),(Pola dana)
-DocType: Supplier,Credit Days,Kreditne Dani
+DocType: Payment Term,Credit Days,Kreditne Dani
 apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Make Student Batch
 DocType: Fee Schedule,FRQ.,FRQ.
 DocType: Leave Type,Is Carry Forward,Je Carry Naprijed
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +815,Get Items from BOM,Kreiraj proizvode od sastavnica (BOM)
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,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
-apps/erpnext/erpnext/controllers/accounts_controller.py +556,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}
+apps/erpnext/erpnext/controllers/accounts_controller.py +600,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
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +182,Not Submitted Salary Slips,Nije dostavila Plaća Slips
 ,Stock Summary,Stock Pregled
-apps/erpnext/erpnext/config/accounts.py +280,Transfer an asset from one warehouse to another,Transfer imovine iz jednog skladišta u drugo
+apps/erpnext/erpnext/config/assets.py +50,Transfer an asset from one warehouse to another,Transfer imovine iz jednog skladišta u drugo
 DocType: Vehicle,Petrol,benzin
 apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Bill of Materials
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,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}
@@ -5236,9 +5603,9 @@
 DocType: Employee Loan Application,Rate of Interest,Kamatna stopa
 DocType: Expense Claim Detail,Sanctioned Amount,Iznos kažnjeni
 DocType: GL Entry,Is Opening,Je Otvaranje
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Row {0}: Debitne stavka ne može se povezati sa {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +194,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 +193,Account {0} does not exist,Konto {0} ne postoji
+apps/erpnext/erpnext/accounts/doctype/account/account.py +179,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.
