diff --git a/erpnext/translations/hr.csv b/erpnext/translations/hr.csv
index 793d495..9e772d2 100644
--- a/erpnext/translations/hr.csv
+++ b/erpnext/translations/hr.csv
@@ -18,10 +18,10 @@
 DocType: Sales Partner,Dealer,Trgovac
 DocType: Employee,Rented,Iznajmljeno
 DocType: POS Profile,Applicable for User,Primjenjivo za članove
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +171,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Zaustavljen Proizvodnja Red ne može biti otkazana, odčepiti najprije otkazati"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +173,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Zaustavljen Proizvodnja Red ne može biti otkazana, odčepiti najprije otkazati"
+apps/erpnext/erpnext/accounts/doctype/asset/asset.js +35,Do you really want to scrap this asset?,Da li zaista želite odbaciti ovu imovinu?
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +36,Currency is required for Price List {0},Valuta je potrebna za cjenik {0}
 DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bit će izračunata u transakciji.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +28,Please setup Employee Naming System in Human Resource &gt; HR Settings,Molimo postavljanje zaposlenika sustav imenovanja u ljudskim resursima&gt; HR Postavke
 DocType: Purchase Order,Customer Contact,Kupac Kontakt
 apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +37,{0} Tree,{0} Tree
 DocType: Job Applicant,Job Applicant,Posao podnositelj
@@ -41,20 +41,22 @@
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +176,Outstanding for {0} cannot be less than zero ({1}),Izvanredna za {0} ne može biti manji od nule ( {1} )
 DocType: Manufacturing Settings,Default 10 mins,Default 10 min
 DocType: Leave Type,Leave Type Name,Naziv vrste odsustva
+apps/erpnext/erpnext/templates/pages/projects.js +81,Show open,Prikaži otvorena
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +148,Series Updated Successfully,Serija je uspješno ažurirana
 DocType: Pricing Rule,Apply On,Nanesite na
 DocType: Item Price,Multiple Item prices.,Višestruke cijene proizvoda.
-,Purchase Order Items To Be Received,Proizvodi narudžbe kupnje - za zaprimiti
+,Purchase Order Items To Be Received,Stavke narudžbenice za zaprimanje
 DocType: SMS Center,All Supplier Contact,Svi kontakti dobavljača
 DocType: Quality Inspection Reading,Parameter,Parametar
-apps/erpnext/erpnext/projects/doctype/project/project.py +43,Expected End Date can not be less than Expected Start Date,Očekivani datum završetka ne može biti manji od očekivanog početka Datum
+apps/erpnext/erpnext/projects/doctype/project/project.py +44,Expected End Date can not be less than Expected Start Date,Očekivani datum završetka ne može biti manji od očekivanog početka Datum
 apps/erpnext/erpnext/utilities/transaction_base.py +107,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Red # {0}: Ocijenite mora biti ista kao {1}: {2} ({3} / {4})
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +229,New Leave Application,Novi dopust Primjena
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +134,Bank Draft,Bank Nacrt
 DocType: Mode of Payment Account,Mode of Payment Account,Način plaćanja računa
 apps/erpnext/erpnext/stock/doctype/item/item.js +49,Show Variants,Pokaži varijante
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +512,Quantity,Količina
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +174,Loans (Liabilities),Zajmovi (pasiva)
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +515,Quantity,Količina
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +504,Accounts table cannot be blank.,Računi stol ne može biti prazno.
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +177,Loans (Liabilities),Zajmovi (pasiva)
 DocType: Employee Education,Year of Passing,Godina Prolazeći
 apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock,Na zalihi
 DocType: Designation,Designation,Oznaka
@@ -64,7 +66,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +31,Health Care,Health Care
 DocType: Purchase Invoice,Monthly,Mjesečno
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +66,Delay in payment (Days),Kašnjenje u plaćanju (dani)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +642,Invoice,Faktura
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +645,Invoice,Faktura
 DocType: Maintenance Schedule Item,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
@@ -81,7 +83,7 @@
 DocType: Cost Center,Stock User,Stock Korisnik
 DocType: Company,Phone No,Telefonski broj
 DocType: Time Log,"Log of Activities performed by users against Tasks that can be used for tracking time, billing.","Zapis aktivnosti korisnika vezanih uz zadatke koji se mogu koristiti za praćenje vremena, naplate."
-apps/erpnext/erpnext/controllers/recurring_document.py +131,New {0}: #{1},Novi {0}: #{1}
+apps/erpnext/erpnext/controllers/recurring_document.py +132,New {0}: #{1},Novi {0}: #{1}
 ,Sales Partners Commission,Provizija prodajnih partnera
 apps/erpnext/erpnext/setup/doctype/company/company.py +38,Abbreviation cannot have more than 5 characters,Kratica ne može imati više od 5 znakova
 DocType: Payment Request,Payment Request,Zahtjev za plaćanje
@@ -102,7 +104,7 @@
 DocType: Employee,Married,Oženjen
 apps/erpnext/erpnext/accounts/party.py +38,Not permitted for {0},Nije dopušteno {0}
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +441,Get items from,Nabavite stavke iz
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +397,Stock cannot be updated against Delivery Note {0},Dionica ne može biti obnovljeno protiv isporuke Napomena {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +390,Stock cannot be updated against Delivery Note {0},Dionica ne može biti obnovljeno protiv isporuke Napomena {0}
 DocType: Payment Reconciliation,Reconcile,pomiriti
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,Trgovina prehrambenom robom
 DocType: Quality Inspection Reading,Reading 1,Čitanje 1
@@ -140,10 +142,11 @@
 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
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +9,Activity Log:,Dnevnik aktivnosti:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +197,Item {0} does not exist in the system or has expired,Proizvod {0} ne postoji u sustavu ili je istekao
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +206,Item {0} does not exist in the system or has expired,Proizvod {0} ne postoji u sustavu ili je istekao
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +44,Real Estate,Nekretnine
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +4,Statement of Account,Izjava o računu
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +41,Pharmaceuticals,Farmaceutske
+DocType: Item,Is Fixed Asset,Je nepokretne imovine
 DocType: Expense Claim Detail,Claim Amount,Iznos štete
 DocType: Employee,Mr,G.
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +33,Supplier Type / Supplier,Dobavljač Tip / Supplier
@@ -156,7 +159,8 @@
 DocType: SMS Center,All Contact,Svi kontakti
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +164,Annual Salary,Godišnja plaća
 DocType: Period Closing Voucher,Closing Fiscal Year,Zatvaranje Fiskalna godina
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +69,Stock Expenses,Stock Troškovi
+apps/erpnext/erpnext/accounts/party.py +326,{0} {1} is frozen,{0} {1} je zamrznuta
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Stock Expenses,Stock Troškovi
 DocType: Newsletter,Email Sent?,Je li e-mail poslan?
 DocType: Journal Entry,Contra Entry,Contra Stupanje
 DocType: Production Order Operation,Show Time Logs,Pokaži Trupci vrijeme
@@ -164,13 +168,13 @@
 DocType: Delivery Note,Installation Status,Status instalacije
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +108,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Količina prihvaćeno + odbijeno mora biti jednaka zaprimljenoj količini proizvoda {0}
 DocType: Item,Supply Raw Materials for Purchase,Nabava sirovine za kupnju
-apps/erpnext/erpnext/stock/get_item_details.py +140,Item {0} must be a Purchase Item,Stavka {0} mora bitikupnja artikla
+apps/erpnext/erpnext/stock/get_item_details.py +139,Item {0} must be a Purchase Item,Stavka {0} mora biti stavka nabave
 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 predložak, ispunite odgovarajuće podatke i priložiti izmijenjene datoteke.
  Sve datume i zaposlenika kombinacija u odabranom razdoblju doći će u predlošku s postojećim pohađanje evidencije"
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +446,Item {0} is not active or end of life has been reached,Proizvod {0} nije aktivan ili nije došao do kraja roka valjanosti
 DocType: Time Log Batch,Will be updated after Sales Invoice is Submitted.,Hoće li se obnavljaju nakon prodaje fakture je Prijavljen.
-apps/erpnext/erpnext/controllers/accounts_controller.py +507,"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/controllers/accounts_controller.py +533,"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 +170,Settings for HR Module,Postavke za HR modula
 DocType: SMS Center,SMS Center,SMS centar
 DocType: BOM Replace Tool,New BOM,Novi BOM
@@ -209,11 +213,11 @@
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Televizija
 DocType: Production Order Operation,Updated via 'Time Log',Ažurirano putem 'Time Log'
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +79,Account {0} does not belong to Company {1},Račun {0} ne pripada tvrtki {1}
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +408,Advance amount cannot be greater than {0} {1},Advance iznos ne može biti veći od {0} {1}
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +413,Advance amount cannot be greater than {0} {1},Advance iznos ne može biti veći od {0} {1}
 DocType: Naming Series,Series List for this Transaction,Serija Popis za ovu transakciju
 DocType: Sales Invoice,Is Opening Entry,Je Otvaranje unos
 DocType: Customer Group,Mention if non-standard receivable account applicable,Spomenuti ako nestandardni potraživanja računa primjenjivo
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +154,For Warehouse is required before Submit,Jer je potrebno Warehouse prije Podnijeti
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +156,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,Primila je u
 DocType: Sales Partner,Reseller,Prodavač
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +24,Please enter Company,Unesite tvrtke
@@ -222,7 +226,7 @@
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +37,Net Cash from Financing,Neto novčani tijek iz financijskih
 DocType: Lead,Address & Contact,Adresa i kontakt
 DocType: Leave Allocation,Add unused leaves from previous allocations,Dodaj neiskorištenih lišće iz prethodnih dodjela
-apps/erpnext/erpnext/controllers/recurring_document.py +217,Next Recurring {0} will be created on {1},Sljedeći ponavljajući {0} bit će izrađen na {1}
+apps/erpnext/erpnext/controllers/recurring_document.py +227,Next Recurring {0} will be created on {1},Sljedeći ponavljajući {0} bit će izrađen na {1}
 DocType: Newsletter List,Total Subscribers,Ukupno Pretplatnici
 ,Contact Name,Kontakt ime
 DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Stvara plaće slip za gore navedene kriterije.
@@ -236,8 +240,8 @@
 apps/erpnext/erpnext/stock/utils.py +178,Warehouse {0} does not belong to company {1},Skladište {0} ne pripada tvrtki {1}
 DocType: Item Website Specification,Item Website Specification,Specifikacija web stranice proizvoda
 DocType: Payment Tool,Reference No,Referentni broj
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +427,Leave Blocked,Neodobreno odsustvo
-apps/erpnext/erpnext/stock/doctype/item/item.py +572,Item {0} has reached its end of life on {1},Proizvod {0} je dosegao svoj rok trajanja na {1}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +425,Leave Blocked,Neodobreno odsustvo
+apps/erpnext/erpnext/stock/doctype/item/item.py +581,Item {0} has reached its end of life on {1},Proizvod {0} je dosegao svoj rok trajanja na {1}
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,Bank Entries,Bankovni tekstova
 apps/erpnext/erpnext/accounts/utils.py +341,Annual,godišnji
 DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock pomirenje točka
@@ -249,10 +253,10 @@
 DocType: Pricing Rule,Supplier Type,Dobavljač Tip
 DocType: Item,Publish in Hub,Objavi na Hub
 ,Terretory,Terretory
-apps/erpnext/erpnext/stock/doctype/item/item.py +592,Item {0} is cancelled,Proizvod {0} je otkazan
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +706,Material Request,Zahtjev za robom
+apps/erpnext/erpnext/stock/doctype/item/item.py +601,Item {0} is cancelled,Proizvod {0} je otkazan
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +709,Material Request,Zahtjev za robom
 DocType: Bank Reconciliation,Update Clearance Date,Ažurirajte provjeri datum
-DocType: Item,Purchase Details,Kupnja Detalji
+DocType: Item,Purchase Details,Detalji nabave
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +323,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Stavka {0} nije pronađena u &quot;sirovina nabavlja se &#39;stol narudžbenice {1}
 DocType: Employee,Relation,Odnos
 DocType: Shipping Rule,Worldwide Shipping,Dostava u svijetu
@@ -265,7 +269,7 @@
 DocType: Notification Control,Notification Control,Obavijest kontrole
 DocType: Lead,Suggestions,Prijedlozi
 DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Postavite proračun za grupu proizvoda na ovom području. Također možete uključiti sezonalnost postavljanjem distribucije.
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +72,Please enter parent account group for warehouse {0},Unesite nadređenu skupinu računa za skladište {0}
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +80,Please enter parent account group for warehouse {0},Unesite nadređenu skupinu računa za skladište {0}
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +249,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plaćanje protiv {0} {1} ne može biti veća od preostali iznos {2}
 DocType: Supplier,Address HTML,Adressa u HTML-u
 DocType: Lead,Mobile No.,Mobitel br.
@@ -276,29 +280,32 @@
 apps/erpnext/erpnext/public/js/setup_wizard.js +20,Max 5 characters,Maksimalno 5 znakova
 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
 apps/erpnext/erpnext/config/desktop.py +83,Learn,Naučiti
+DocType: Asset,Next Depreciation Date,Sljedeći datum Amortizacija
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Aktivnost Cijena po zaposlenom
 DocType: Accounts Settings,Settings for Accounts,Postavke za račune
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +483,Supplier Invoice No exists in Purchase Invoice {0},Dobavljač Račun br postoji u fakturi {0}
 apps/erpnext/erpnext/config/crm.py +110,Manage Sales Person Tree.,Uredi raspodjelu prodavača.
 DocType: Job Applicant,Cover Letter,Pismo
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Outstanding Cheques and Deposits to clear,Izvanredna Čekovi i depoziti za brisanje
 DocType: Item,Synced With Hub,Sinkronizirati s Hub
 apps/erpnext/erpnext/setup/doctype/company/company.js +63,Wrong Password,Pogrešna Lozinka
 DocType: Item,Variant Of,Varijanta
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +313,Completed Qty can not be greater than 'Qty to Manufacture',Završen Qty ne može biti veći od 'Kol proizvoditi'
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +315,Completed Qty can not be greater than 'Qty to Manufacture',Završen Qty ne može biti veći od 'Kol proizvoditi'
 DocType: Period Closing Voucher,Closing Account Head,Zatvaranje računa šefa
 DocType: Employee,External Work History,Vanjski Povijest Posao
 apps/erpnext/erpnext/projects/doctype/task/task.py +86,Circular Reference Error,Kružni Referentna Greška
 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.
+apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jedinica [{1}] (# Form / Artikl / {1}) naći u [{2}] (# Form / Skladište / {2})
 DocType: Lead,Industry,Industrija
 DocType: Employee,Job Profile,Profil posla
 DocType: Newsletter,Newsletter,Bilten
 DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Obavijest putem maila prilikom stvaranja automatskog Zahtjeva za robom
 DocType: Journal Entry,Multi Currency,Više valuta
 DocType: Payment Reconciliation Invoice,Invoice Type,Tip fakture
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +708,Delivery Note,Otpremnica
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +751,Delivery Note,Otpremnica
 apps/erpnext/erpnext/config/learn.py +87,Setting up Taxes,Postavljanje Porezi
 apps/erpnext/erpnext/accounts/utils.py +191,Payment Entry has been modified after you pulled it. Please pull it again.,Ulazak Plaćanje je izmijenjen nakon što ga je izvukao. Ponovno izvucite ga.
-apps/erpnext/erpnext/stock/doctype/item/item.py +381,{0} entered twice in Item Tax,{0} dva puta ušao u točki poreza
+apps/erpnext/erpnext/stock/doctype/item/item.py +386,{0} entered twice in Item Tax,{0} dva puta ušao u točki poreza
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +105,Summary for this week and pending activities,Sažetak za ovaj tjedan i tijeku aktivnosti
 DocType: Workstation,Rent Cost,Rent cost
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +73,Please select month and year,Molimo odaberite mjesec i godinu
@@ -309,19 +316,19 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js +48,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,"Ova točka je predložak i ne može se koristiti u prometu. Atributi artikl će biti kopirana u varijanti osim 'Ne Copy ""je postavljena"
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Ukupno Naručite Smatra
 apps/erpnext/erpnext/config/hr.py +190,"Employee designation (e.g. CEO, Director etc.).","Oznaka zaposlenika ( npr. CEO , direktor i sl. ) ."
-apps/erpnext/erpnext/controllers/recurring_document.py +210,Please enter 'Repeat on Day of Month' field value,Unesite ' ponovite na dan u mjesecu ' na terenu vrijednosti
+apps/erpnext/erpnext/controllers/recurring_document.py +220,Please enter 'Repeat on Day of Month' field value,Unesite ' ponovite na dan u mjesecu ' na terenu vrijednosti
 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: Features Setup,"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Dostupno u sastavnicama, otpremnicama, računu kupnje, nalogu za proizvodnju, narudžbi kupnje, primci, prodajnom računu, narudžbi kupca, ulaznog naloga i kontrolnoj kartici"
 DocType: Item Tax,Tax Rate,Porezna stopa
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +54,{0} already allocated for Employee {1} for period {2} to {3},{0} već dodijeljeno za zaposlenika {1} za vrijeme {2} {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +674,Select Item,Odaberite stavku
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +677,Select Item,Odaberite stavku
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Item: {0} managed batch-wise, can not be reconciled using \
 					Stock Reconciliation, instead use Stock Entry","Stavka: {0} uspio turi, ne mogu se pomiriti pomoću \
  skladišta pomirenje, umjesto da koristite Stock unos"
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +254,Purchase Invoice {0} is already submitted,Kupnja Račun {0} već je podnijela
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +254,Purchase Invoice {0} is already submitted,Nabavni račun {0} je već podnesen
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +90,Row # {0}: Batch No must be same as {1} {2},Red # {0}: Batch Ne mora biti ista kao {1} {2}
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +65,Convert to non-Group,Pretvori u ne-Group
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Purchase Receipt must be submitted,Kupnja Potvrda mora biti podnesen
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Purchase Receipt must be submitted,Primka mora biti zaprimljena
 apps/erpnext/erpnext/config/stock.py +118,Batch (lot) of an Item.,Serija (puno) proizvoda.
 DocType: C-Form Invoice Detail,Invoice Date,Datum računa
 DocType: GL Entry,Debit Amount,Duguje iznos
@@ -337,9 +344,9 @@
 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}
 DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Parametar provjere kvalitete proizvoda
 DocType: Leave Application,Leave Approver Name,Ime osobe ovlaštene za odobrenje odsustva
-,Schedule Date,Raspored Datum
+DocType: Depreciation Schedule,Schedule Date,Raspored Datum
 DocType: Packed Item,Packed Item,Pakirani proizvod
-apps/erpnext/erpnext/config/buying.py +60,Default settings for buying transactions.,Zadane postavke za transakciju kupnje.
+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šak postoji zaposlenom {0} protiv tip aktivnosti - {1}
 apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +29,Please do NOT create Accounts for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Molimo vas da ne stvaraju računi za kupce i dobavljače. Oni su stvorili izravno iz Kupac / Dobavljač majstora.
 DocType: Currency Exchange,Currency Exchange,Mjenjačnica
@@ -348,10 +355,11 @@
 apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Credit Balance,Kreditna bilanca
 DocType: Employee,Widowed,Udovički
 DocType: Production Planning Tool,"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty",Proizvodi se traži što su &quot;Out of Stock&quot; s obzirom na sve skladišta na temelju projicirane Qty i minimalne narudžbe Kol
+DocType: Request for Quotation,Request for Quotation,Zahtjev za ponudu
 DocType: Workstation,Working Hours,Radnih sati
 DocType: Naming Series,Change the starting / current sequence number of an existing series.,Promjena polaznu / tekući redni broj postojeće serije.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +57,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Ako više Cijene pravila i dalje prevladavaju, korisnici su zamoljeni da postavite prioritet ručno riješiti sukob."
-,Purchase Register,Kupnja Registracija
+,Purchase Register,Popis nabave
 DocType: Landed Cost Item,Applicable Charges,Troškove u
 DocType: Workstation,Consumable Cost,potrošni cost
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +192,{0} ({1}) must have role 'Leave Approver',"{0} ({1}) mora imati ulogu ""Odobritelj odsustva '"
@@ -366,7 +374,7 @@
 DocType: Purchase Invoice,Yearly,Godišnji
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +229,Please enter Cost Center,Unesite troška
 DocType: Journal Entry Account,Sales Order,Narudžba kupca
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +67,Avg. Selling Rate,AVG. Prodajnom tečaju
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +67,Avg. Selling Rate,Prosječna prodajna cijena
 apps/erpnext/erpnext/utilities/transaction_base.py +131,Quantity cannot be a fraction in row {0},Količina ne može biti dio u redku {0}
 DocType: Purchase Invoice Item,Quantity and Rate,Količina i stopa
 DocType: Delivery Note,% Installed,% Instalirano
@@ -388,15 +396,16 @@
 apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Globalne postavke za sve proizvodne procese.
 DocType: Accounts Settings,Accounts Frozen Upto,Računi Frozen Upto
 DocType: SMS Log,Sent On,Poslan Na
-apps/erpnext/erpnext/stock/doctype/item/item.py +550,Attribute {0} selected multiple times in Attributes Table,Osobina {0} izabrani više puta u Svojstva tablice
+apps/erpnext/erpnext/stock/doctype/item/item.py +555,Attribute {0} selected multiple times in Attributes Table,Osobina {0} izabrani više puta u Svojstva tablice
 DocType: HR Settings,Employee record is created using selected field. ,Zaposlenika rekord je stvorio pomoću odabranog polja.
 DocType: Sales Order,Not Applicable,Nije primjenjivo
 apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Majstor za odmor .
-DocType: Material Request Item,Required Date,Potrebna Datum
+DocType: Request for Quotation Item,Required Date,Potrebna Datum
 DocType: Delivery Note,Billing Address,Adresa za naplatu
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +770,Please enter Item Code.,Unesite kod artikal .
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +773,Please enter Item Code.,Unesite kod artikal .
 DocType: BOM,Costing,Koštanje
 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
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Ukupna količina
 DocType: Employee,Health Concerns,Zdravlje Zabrinutost
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +15,Unpaid,Neplaćen
@@ -418,17 +427,17 @@
 apps/erpnext/erpnext/public/js/feature_setup.js +220,""" does not exists",""" ne postoji"
 DocType: Pricing Rule,Valid Upto,Vrijedi Upto
 apps/erpnext/erpnext/public/js/setup_wizard.js +212,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/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Direct Income,Izravni dohodak
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +146,Direct Income,Izravni dohodak
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +33,"Can not filter based on Account, if grouped by Account","Ne možete filtrirati na temelju računa, ako je grupirano po računu"
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Administrative Officer,Administrativni službenik
 DocType: Payment Tool,Received Or Paid,Primiti ili platiti
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +308,Please select Company,Odaberite tvrtke
 DocType: Stock Entry,Difference Account,Račun razlike
 apps/erpnext/erpnext/projects/doctype/task/task.py +44,Cannot close task as its dependant task {0} is not closed.,Ne može zatvoriti zadatak kao njegova ovisna zadatak {0} nije zatvoren.
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +378,Please enter Warehouse for which Material Request will be raised,Unesite skladište za koje Materijal Zahtjev će biti podignuta
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +381,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 trošak
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,kozmetika
-apps/erpnext/erpnext/stock/doctype/item/item.py +454,"To merge, following properties must be same for both items","Spojiti , ova svojstva moraju biti isti za obje stavke"
+apps/erpnext/erpnext/stock/doctype/item/item.py +459,"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,Telefon hitne službe
 ,Serial No Warranty Expiry,Istek jamstva serijskog broja
@@ -437,6 +446,7 @@
 DocType: Journal Entry,Difference (Dr - Cr),Razlika ( dr. - Cr )
 DocType: Account,Profit and Loss,Račun dobiti i gubitka
 apps/erpnext/erpnext/config/stock.py +315,Managing Subcontracting,Upravljanje podugovaranje
+DocType: Project,Project will be accessible on the website to these users,Projekt će biti dostupan na web-stranici ovih korisnika
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +47,Furniture and Fixture,Namještaj i susret
 DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Stopa po kojoj Cjenik valute se pretvaraju u tvrtke bazne valute
 apps/erpnext/erpnext/setup/doctype/company/company.py +53,Account {0} does not belong to company: {1},Račun {0} ne pripada tvrtki: {1}
@@ -448,7 +458,7 @@
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +27,Increment cannot be 0,Prirast ne može biti 0
 DocType: Production Planning Tool,Material Requirement,Preduvjet za robu
 DocType: Company,Delete Company Transactions,Brisanje transakcije tvrtke
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +86,Item {0} is not Purchase Item,Proizvod {0} nije nabavni proizvod
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Item {0} is not Purchase Item,Proizvod {0} nije nabavni proizvod
 DocType: Purchase Receipt,Add / Edit Taxes and Charges,Dodaj / uredi porez i pristojbe
 DocType: Purchase Invoice,Supplier Invoice No,Dobavljač Račun br
 DocType: Territory,For reference,Za referencu
@@ -459,23 +469,23 @@
 DocType: Production Plan Item,Pending Qty,U tijeku Kom
 DocType: Company,Ignore,Ignorirati
 apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +86,SMS sent to following numbers: {0},SMS poslan na sljedećim brojevima: {0}
-apps/erpnext/erpnext/controllers/buying_controller.py +126,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dobavljač skladišta obvezan je za sub - ugovoreni kupiti primitka
+apps/erpnext/erpnext/controllers/buying_controller.py +127,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
 DocType: Sales Invoice,Total Commission,Ukupno komisija
 DocType: Pricing Rule,Sales Partner,Prodajni partner
-DocType: Buying Settings,Purchase Receipt Required,Kupnja Potvrda Obvezno
+DocType: Buying Settings,Purchase Receipt Required,Primka je obvezna
 DocType: Monthly Distribution,"**Monthly Distribution** helps you distribute your budget across months if you have seasonality in your business.
 
 To distribute a budget using this distribution, set this **Monthly Distribution** in the **Cost Center**","**Mjesečna distribucija** vam pomaže u raspodjeli proračuna po mjesecima, ako imate sezonalnost u svom poslovanju. Kako bi distribuirali proračun pomoću ove distribucije, postavite **Mjesečna distribucija** u **Troškovnom centru**"
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +126,No records found in the Invoice table,Nisu pronađeni zapisi u tablici računa
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +20,Please select Company and Party Type first,Odaberite Društvo i Zabava Tip prvi
-apps/erpnext/erpnext/config/accounts.py +230,Financial / accounting year.,Financijska / obračunska godina.
+apps/erpnext/erpnext/config/accounts.py +238,Financial / accounting year.,Financijska / obračunska godina.
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.js +10,Accumulated Values,Akumulirani Vrijednosti
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Sorry, Serial Nos cannot be merged","Žao nam je , Serial Nos ne mogu spojiti"
 DocType: Project Task,Project Task,Zadatak projekta
 ,Lead Id,Id potencijalnog kupca
 DocType: C-Form Invoice Detail,Grand Total,Ukupno za platiti
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +35,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
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +36,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Fiskalna godina Start Date ne bi trebao biti veći od Fiskalna godina End Date
 DocType: Warranty Claim,Resolution,Rezolucija
 apps/erpnext/erpnext/templates/pages/order.html +61,Delivered: {0},Isporučuje se: {0}
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +66,Payable Account,Obveze prema dobavljačima
@@ -483,7 +493,7 @@
 DocType: Job Applicant,Resume Attachment,Nastavi Prilog
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Ponoviti kupaca
 DocType: Leave Control Panel,Allocate,Dodijeliti
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +640,Sales Return,Povrat robe
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +683,Sales Return,Povrat robe
 DocType: Item,Delivered by Supplier (Drop Ship),Dostavlja Dobavljač (Drop Ship)
 apps/erpnext/erpnext/config/hr.py +115,Salary components.,Komponente plaće
 apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Baza potencijalnih kupaca.
@@ -492,7 +502,7 @@
 DocType: Quotation,Quotation To,Ponuda za
 DocType: Lead,Middle Income,Srednji Prihodi
 apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +58,Opening (Cr),Otvaranje ( Cr )
-apps/erpnext/erpnext/stock/doctype/item/item.py +698,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.,"Zadana mjerna jedinica za točke {0} se ne može mijenjati izravno, jer ste već napravili neke transakcije (e) s drugim UOM. Morat ćete stvoriti novu stavku za korištenje drugačiji Default UOM."
+apps/erpnext/erpnext/stock/doctype/item/item.py +707,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.,"Zadana mjerna jedinica za točke {0} se ne može mijenjati izravno, jer ste već napravili neke transakcije (e) s drugim UOM. Morat ćete stvoriti novu stavku za korištenje drugačiji Default UOM."
 apps/erpnext/erpnext/accounts/utils.py +195,Allocated amount can not be negative,Dodijeljeni iznos ne može biti negativan
 DocType: Purchase Order Item,Billed Amt,Naplaćeno Amt
 DocType: Warehouse,A logical Warehouse against which stock entries are made.,Logično Skladište protiv kojih su dionice unosi se.
@@ -502,7 +512,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +139,Proposal Writing,Pisanje prijedlog
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Još jedna prodaja Osoba {0} postoji s istim ID zaposlenika
 apps/erpnext/erpnext/config/accounts.py +70,Masters,Masteri
-apps/erpnext/erpnext/config/accounts.py +127,Update Bank Transaction Dates,Transakcijski Termini Update banke
+apps/erpnext/erpnext/config/accounts.py +135,Update Bank Transaction Dates,Transakcijski Termini Update banke
 apps/erpnext/erpnext/stock/stock_ledger.py +337,Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negativni lager - greška ( {6} ) za proizvod {0} u skladištu {1} na {2} {3} u {4} {5}
 apps/erpnext/erpnext/config/projects.py +30,Time Tracking,praćenje vremena
 DocType: Fiscal Year Company,Fiscal Year Company,Fiskalna godina - tvrtka
@@ -520,27 +530,27 @@
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +62,Please enter Purchase Receipt first,Unesite prvo primku
 DocType: Buying Settings,Supplier Naming By,Dobavljač nazivanje
 DocType: Activity Type,Default Costing Rate,Zadana Obračun troškova stopa
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +660,Maintenance Schedule,Raspored održavanja
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +703,Maintenance Schedule,Raspored održavanja
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +34,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Cjenovna pravila filtriraju se na temelju kupca, grupe kupaca, regije, dobavljača, proizvođača, kampanje, prodajnog partnera i sl."
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Inventory,Neto promjena u inventar
 DocType: Employee,Passport Number,Broj putovnice
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +82,Manager,Upravitelj
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +220,Same item has been entered multiple times.,Isti predmet je ušao više puta.
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +229,Same item has been entered multiple times.,Isti predmet je ušao više puta.
 DocType: SMS Settings,Receiver Parameter,Prijemnik parametra
 apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,'Temelji se na' i 'Grupiranje po' ne mogu biti isti
 DocType: Sales Person,Sales Person Targets,Prodajni plan prodavača
 DocType: Production Order Operation,In minutes,U minuta
 DocType: Issue,Resolution Date,Rezolucija Datum
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +239,Please set a Holiday List for either the Employee or the Company,Postavite odmor popis za bilo zaposlenik ili Društvo
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +674,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/accounts/doctype/sales_invoice/sales_invoice.py +699,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}
 DocType: Selling Settings,Customer Naming By,Imenovanje kupca prema
+DocType: Depreciation Schedule,Depreciation Amount,Amortizacija Iznos
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +69,Convert to Group,Pretvori u Grupi
 DocType: Activity Cost,Activity Type,Tip aktivnosti
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Isporučeno Iznos
 DocType: Supplier,Fixed Days,Fiksni dana
 DocType: Quotation Item,Item Balance,Stanje predmeta
 DocType: Sales Invoice,Packing List,Popis pakiranja
-apps/erpnext/erpnext/config/buying.py +23,Purchase Orders given to Suppliers.,Kupnja naloge koje je dao dobavljače.
+apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Narudžbenice poslane dobavljačima
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,objavljivanje
 DocType: Activity Cost,Projects User,Projekti za korisnike
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Konzumira
@@ -555,8 +565,10 @@
 DocType: BOM Operation,Operation Time,Operacija vrijeme
 DocType: Pricing Rule,Sales Manager,Sales Manager
 apps/erpnext/erpnext/accounts/doctype/account/account.js +67,Group to Group,Skupine do skupine
+apps/erpnext/erpnext/projects/doctype/project/project.py +164,My Projects,Moji projekti
 DocType: Journal Entry,Write Off Amount,Napišite paušalni iznos
 DocType: Journal Entry,Bill No,Bill Ne
+DocType: Company,Gain/Loss Account on Asset Disposal,Dobitak / Gubitak računa na sredstva Odlaganje
 DocType: Purchase Invoice,Quarterly,Tromjesečni
 DocType: Selling Settings,Delivery Note Required,Potrebna je otpremnica
 DocType: Sales Order Item,Basic Rate (Company Currency),Osnovna stopa (valuta tvrtke)
@@ -568,13 +580,14 @@
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +223,Payment Entry is already created,Ulazak Plaćanje je već stvorio
 DocType: Features Setup,To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Za praćenje stavke u prodaji i kupnji dokumenata na temelju njihovih serijskih br. To je također može koristiti za praćenje jamstvene podatke o proizvodu.
 DocType: Purchase Receipt Item Supplied,Current Stock,Trenutačno stanje skladišta
+apps/erpnext/erpnext/controllers/accounts_controller.py +473,Row #{0}: Asset {1} does not linked to Item {2},Red # {0}: Imovina {1} ne povezan s točkom {2}
 apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +67,Total billing this year,Ukupno naplatu ove godine
 DocType: Account,Expenses Included In Valuation,Troškovi uključeni u vrednovanje
 DocType: Employee,Provide email id registered in company,Osigurati e id registriran u tvrtki
 DocType: Hub Settings,Seller City,Prodavač Grad
 DocType: Email Digest,Next email will be sent on:,Sljedeći email će biti poslan na:
 DocType: Offer Letter Term,Offer Letter Term,Ponuda pismo Pojam
-apps/erpnext/erpnext/stock/doctype/item/item.py +529,Item has variants.,Stavka ima varijante.
+apps/erpnext/erpnext/stock/doctype/item/item.py +534,Item has variants.,Stavka ima varijante.
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +67,Item {0} not found,Stavka {0} nije pronađena
 DocType: Bin,Stock Value,Stock vrijednost
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +88,Tree Type,Tree Type
@@ -597,6 +610,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +91,{0} is not a stock Item,{0} nije skladišni proizvod
 DocType: Mode of Payment Account,Default Account,Zadani račun
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +155,Lead must be set if Opportunity is made from Lead,Potencijalni kupac mora biti postavljen ako je prilika iz njega izrađena
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +49,Customer &gt; Customer Group &gt; Territory,Kupac&gt; Korisnička Group&gt; Regija
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Odaberite tjednik off dan
 DocType: Production Order Operation,Planned End Time,Planirani End Time
 ,Sales Person Target Variance Item Group-Wise,Pregled prometa po prodavaču i grupi proizvoda
@@ -611,14 +625,14 @@
 apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Mjesečna plaća izjava.
 DocType: Item Group,Website Specifications,Web Specifikacije
 apps/erpnext/erpnext/utilities/doctype/address/address.py +103,There is an error in your Address Template {0},Došlo je do pogreške u vašem adresnoj predložak {0}
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +204,New Account,Novi račun
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +207,New Account,Novi račun
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +23,{0}: From {0} of type {1},{0}: Od {0} od tipa {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +274,Row {0}: Conversion Factor is mandatory,Red {0}: pretvorbe Factor je obvezno
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +271,"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 rješavanje sukoba dodjeljivanjem prioriteta. Pravila Cijena: {0}"
+apps/erpnext/erpnext/controllers/buying_controller.py +275,Row {0}: Conversion Factor is mandatory,Red {0}: pretvorbe Factor je obvezno
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +274,"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 rješavanje sukoba dodjeljivanjem prioriteta. Pravila Cijena: {0}"
 apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +27,Accounting Entries can be made against leaf nodes. Entries against Groups are not allowed.,Računovodstvo Prijave se mogu podnijeti protiv lisnih čvorova. Prijave protiv grupe nije dopušteno.
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +362,Cannot deactivate or cancel BOM as it is linked with other BOMs,Ne može deaktivirati ili otkazati BOM kao što je povezano s drugim sastavnicama
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +371,Cannot deactivate or cancel BOM as it is linked with other BOMs,Ne može deaktivirati ili otkazati BOM kao što je povezano s drugim sastavnicama
 DocType: Opportunity,Maintenance,Održavanje
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +188,Purchase Receipt number required for Item {0},Broj primke je potreban za artikal {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +190,Purchase Receipt number required for Item {0},Broj primke je potreban za artikal {0}
 DocType: Item Attribute Value,Item Attribute Value,Stavka Vrijednost atributa
 apps/erpnext/erpnext/config/crm.py +84,Sales campaigns.,Prodajne kampanje.
 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.
@@ -666,17 +680,17 @@
 DocType: Address,Personal,Osobno
 DocType: Expense Claim Detail,Expense Claim Type,Rashodi Vrsta polaganja
 DocType: Shopping Cart Settings,Default settings for Shopping Cart,Zadane postavke za Košarica
-apps/erpnext/erpnext/controllers/accounts_controller.py +320,"Journal Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Temeljnica {0} povezan protiv Red {1}, provjerite je li to trebalo biti izdvajali kao unaprijed u ovom računu."
+apps/erpnext/erpnext/controllers/accounts_controller.py +333,"Journal Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Temeljnica {0} povezan protiv Red {1}, provjerite je li to trebalo biti izdvajali kao unaprijed u ovom računu."
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Biotehnologija
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +108,Office Maintenance Expenses,Troškovi održavanja ureda
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Office Maintenance Expenses,Troškovi održavanja ureda
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +111,Please enter Item first,Unesite predmeta prvi
 DocType: Account,Liability,Odgovornost
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +60,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Kažnjeni Iznos ne može biti veći od Zahtjeva Iznos u nizu {0}.
 DocType: Company,Default Cost of Goods Sold Account,Zadana vrijednost prodane robe računa
-apps/erpnext/erpnext/stock/get_item_details.py +275,Price List not selected,Popis Cijena ne bira
+apps/erpnext/erpnext/stock/get_item_details.py +274,Price List not selected,Popis Cijena ne bira
 DocType: Employee,Family Background,Obitelj Pozadina
 DocType: Process Payroll,Send Email,Pošaljite e-poštu
-apps/erpnext/erpnext/stock/doctype/item/item.py +147,Warning: Invalid Attachment {0},Upozorenje: Invalid Prilog {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +152,Warning: Invalid Attachment {0},Upozorenje: Invalid Prilog {0}
 apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +88,No Permission,Nemate dopuštenje
 DocType: Company,Default Bank Account,Zadani bankovni račun
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +47,"To filter based on Party, select Party Type first","Za filtriranje se temelji na stranke, odaberite stranka Upišite prvi"
@@ -684,7 +698,8 @@
 apps/erpnext/erpnext/public/js/setup_wizard.js +272,Nos,Kom
 DocType: Item,Items with higher weightage will be shown higher,Stavke sa višim weightage će se prikazati više
 DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Banka Pomirenje Detalj
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +666,My Invoices,Moji Računi
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +691,My Invoices,Moji Računi
+apps/erpnext/erpnext/controllers/accounts_controller.py +476,Row #{0}: Asset {1} must be submitted,Red # {0}: Imovina {1} mora biti predana
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +43,No employee found,Nisu pronađeni zaposlenici
 DocType: Supplier Quotation,Stopped,Zaustavljen
 DocType: Item,If subcontracted to a vendor,Ako podugovoren dobavljaču
@@ -693,10 +708,11 @@
 apps/erpnext/erpnext/config/stock.py +149,Upload stock balance via csv.,Prenesi dionica ravnotežu putem CSV.
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +27,Send Now,Pošalji odmah
 ,Support Analytics,Analitike podrške
+apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +196,Logical error: Must find overlapping,Logička pogreška: Mora naći preklapanje
 DocType: Item,Website Warehouse,Skladište web stranice
 DocType: Payment Reconciliation,Minimum Invoice Amount,Minimalni iznos fakture
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Rezultat mora biti manja od ili jednaka 5
-apps/erpnext/erpnext/config/accounts.py +267,C-Form records,C-obrazac zapisi
+apps/erpnext/erpnext/config/accounts.py +275,C-Form records,C-obrazac zapisi
 apps/erpnext/erpnext/config/selling.py +301,Customer and Supplier,Kupaca i dobavljača
 DocType: Email Digest,Email Digest Settings,E-pošta postavke
 apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Upiti podršci.
@@ -716,11 +732,11 @@
 DocType: Production Order,Item To Manufacture,Proizvod za proizvodnju
 apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +87,{0} {1} status is {2},{0} {1} status {2}
 DocType: Shopping Cart Settings,Enable Checkout,Omogući Checkout
-apps/erpnext/erpnext/config/learn.py +207,Purchase Order to Payment,Narudžbenica za plaćanje
+apps/erpnext/erpnext/config/learn.py +207,Purchase Order to Payment,Narudžbenice za plaćanje
 DocType: Quotation Item,Projected Qty,Predviđena količina
 DocType: Sales Invoice,Payment Due Date,Plaćanje Due Date
 DocType: Newsletter,Newsletter Manager,Newsletter Upravitelj
-apps/erpnext/erpnext/stock/doctype/item/item.js +240,Item Variant {0} already exists with same attributes,Stavka Varijanta {0} već postoji s istim atributima
+apps/erpnext/erpnext/stock/doctype/item/item.js +227,Item Variant {0} already exists with same attributes,Stavka Varijanta {0} već postoji s istim atributima
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +95,'Opening',&quot;Otvaranje &#39;
 DocType: Notification Control,Delivery Note Message,Otpremnica - poruka
 DocType: Expense Claim,Expenses,troškovi
@@ -757,14 +773,15 @@
 DocType: Supplier Quotation,Is Subcontracted,Je podugovarati
 DocType: Item Attribute,Item Attribute Values,Stavka vrijednosti atributa
 apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +3,View Subscribers,Pogledaj Pretplatnici
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +618,Purchase Receipt,Primka
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +621,Purchase Receipt,Primka
 ,Received Items To Be Billed,Primljeni Proizvodi se naplaćuje
 DocType: Employee,Ms,Gospođa
-apps/erpnext/erpnext/config/accounts.py +240,Currency exchange rate master.,Majstor valute .
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +263,Unable to find Time Slot in the next {0} days for Operation {1},Nije moguće pronaći termin u narednih {0} dana za rad {1}
+apps/erpnext/erpnext/config/accounts.py +248,Currency exchange rate master.,Majstor valute .
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +265,Unable to find Time Slot in the next {0} days for Operation {1},Nije moguće pronaći termin u narednih {0} dana za rad {1}
 DocType: Production Order,Plan material for sub-assemblies,Plan materijal za pod-sklopova
 apps/erpnext/erpnext/config/selling.py +99,Sales Partners and Territory,Prodaja Partneri i Županija
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +427,BOM {0} must be active,BOM {0} mora biti aktivna
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +436,BOM {0} must be active,BOM {0} mora biti aktivna
+DocType: Journal Entry,Depreciation Entry,Amortizacija Ulaz
 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/templates/generators/item.html +74,Goto Cart,Idi košarica
 apps/erpnext/erpnext/support/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
@@ -783,7 +800,7 @@
 DocType: Supplier,Default Payable Accounts,Zadane naplativo račune
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +40,Employee {0} is not active or does not exist,Zaposlenik {0} nije aktivan ili ne postoji
 DocType: Features Setup,Item Barcode,Barkod proizvoda
-apps/erpnext/erpnext/stock/doctype/item/item.py +524,Item Variants {0} updated,Stavka Varijante {0} ažurirani
+apps/erpnext/erpnext/stock/doctype/item/item.py +529,Item Variants {0} updated,Stavka Varijante {0} ažurirani
 DocType: Quality Inspection Reading,Reading 6,Čitanje 6
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Ulazni račun - predujam
 DocType: Address,Shop,Dućan
@@ -793,10 +810,10 @@
 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 +139,The Brand,Brand
-apps/erpnext/erpnext/controllers/status_updater.py +163,Allowance for over-{0} crossed for Item {1}.,Dodatak za prekomjerno {0} prešao za točku {1}.
+apps/erpnext/erpnext/controllers/status_updater.py +165,Allowance for over-{0} crossed for Item {1}.,Dodatak za prekomjerno {0} prešao za točku {1}.
 DocType: Employee,Exit Interview Details,Izlaz Intervju Detalji
 DocType: Item,Is Purchase Item,Je dobavljivi proizvod
-DocType: Journal Entry Account,Purchase Invoice,Ulazni račun
+DocType: Asset,Purchase Invoice,Ulazni račun
 DocType: Stock Ledger Entry,Voucher Detail No,Bon Detalj Ne
 DocType: Stock Entry,Total Outgoing Value,Ukupna odlazna vrijednost
 apps/erpnext/erpnext/public/js/account_tree_grid.js +225,Opening Date and Closing Date should be within same Fiscal Year,Otvaranje i zatvaranje Datum datum mora biti unutar iste fiskalne godine
@@ -804,23 +821,26 @@
 DocType: Payment Request,Paid,Plaćen
 DocType: Salary Slip,Total in words,Ukupno je u riječima
 DocType: Material Request Item,Lead Time Date,Potencijalni kupac - datum
-apps/erpnext/erpnext/public/js/controllers/taxes_and_totals.js +54, is mandatory. Maybe Currency Exchange record is not created for ,je obavezno. Možda Mjenjačnica zapis nije stvoren za
+apps/erpnext/erpnext/public/js/controllers/taxes_and_totals.js +54, is mandatory. Maybe Currency Exchange record is not created for ,je obavezno. Možta nije upisan tečaj za
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +110,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 +539,"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;proizvod Bundle&#39; predmeta, skladište, rednim i hrpa Ne smatrat će se iz &quot;Popis pakiranja &#39;stol. Ako Skladište i serije ne su isti za sve pakiranje predmeta za bilo &#39;proizvod Bundle&#39; točke, te vrijednosti može se unijeti u glavnoj točki stol, vrijednosti će se kopirati u &#39;pakiranje popis&#39; stol."
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +542,"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;proizvod Bundle&#39; predmeta, skladište, rednim i hrpa Ne smatrat će se iz &quot;Popis pakiranja &#39;stol. Ako Skladište i serije ne su isti za sve pakiranje predmeta za bilo &#39;proizvod Bundle&#39; točke, te vrijednosti može se unijeti u glavnoj točki stol, vrijednosti će se kopirati u &#39;pakiranje popis&#39; stol."
 DocType: Job Opening,Publish on website,Objavi na web stranici
 apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Isporuke kupcima.
-DocType: Purchase Invoice Item,Purchase Order Item,Narudžbenica predmet
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Indirect Income,Neizravni dohodak
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +463,Supplier Invoice Date cannot be greater than Posting Date,Datum Dobavljač Račun ne može biti veća od datum knjiženja
+DocType: Purchase Invoice Item,Purchase Order Item,Stavka narudžbenice
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Indirect Income,Neizravni dohodak
 DocType: Payment Tool,Set Payment Amount = Outstanding Amount,Postavi Iznos Plaćanje = Izvanredna Iznos
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +53,Variance,Varijacija
 ,Company Name,Ime tvrtke
 DocType: SMS Center,Total Message(s),Ukupno poruka ( i)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +672,Select Item for Transfer,Odaberite stavke za prijenos
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +675,Select Item for Transfer,Odaberite stavke za prijenos
 DocType: Purchase Invoice,Additional Discount Percentage,Dodatni Postotak Popust
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Pregled popisa svih pomoć videa
 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,Dopusti korisniku uređivanje cjenika u transakcijama
 DocType: Pricing Rule,Max Qty,Maksimalna količina
+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 bi moglo biti poništena / ne postoji. \ Unesite valjanu fakture"
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Red {0}: Plaćanje protiv prodaje / narudžbenice treba uvijek biti označena kao unaprijed
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +16,Chemical,kemijski
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +681,All items have already been transferred for this Production Order.,Svi predmeti su već prebačeni za ovu radnog naloga.
@@ -829,14 +849,14 @@
 DocType: HR Settings,Don't send Employee Birthday Reminders,Ne šaljite podsjetnik za rođendan zaposlenika
 ,Employee Holiday Attendance,Zaposlenik odmor posjećenost
 DocType: Opportunity,Walk In,Šetnja u
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +64,Stock Entries,Stock tekstova
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +65,Stock Entries,Stock tekstova
 DocType: Item,Inspection Criteria,Inspekcijski Kriteriji
 apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +12,Transfered,Prenose
 apps/erpnext/erpnext/public/js/setup_wizard.js +140,Upload your letter head and logo. (you can edit them later).,Upload Vaše pismo glavu i logotip. (Možete ih uređivati kasnije).
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +156,White,Bijela
 DocType: SMS Center,All Lead (Open),Svi potencijalni kupci (aktualni)
 DocType: Purchase Invoice,Get Advances Paid,Kreiraj avansno plaćanje
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +595,Make ,Napravi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +598,Make ,Napravi
 DocType: Journal Entry,Total Amount in Words,Ukupan iznos riječima
 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
@@ -846,7 +866,8 @@
 DocType: Holiday List,Holiday List Name,Turistička Popis Ime
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +168,Stock Options,Burzovnih opcija
 DocType: Journal Entry Account,Expense Claim,Rashodi polaganja
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +180,Qty for {0},Količina za {0}
+apps/erpnext/erpnext/accounts/doctype/asset/asset.js +49,Do you really want to restore this scrapped asset?,Da li stvarno želite vratiti ovaj otpisan imovine?
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +181,Qty for {0},Količina za {0}
 DocType: Leave Application,Leave Application,Zahtjev za odsustvom
 apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Alat za raspodjelu odsustva
 DocType: Leave Block List,Leave Block List Dates,Datumi popisa neodobrenih odsustava
@@ -859,11 +880,11 @@
 DocType: POS Profile,Cash/Bank Account,Novac / bankovni račun
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +70,Removed items with no change in quantity or value.,Uklonjene stvari bez promjena u količini ili vrijednosti.
 DocType: Delivery Note,Delivery To,Dostava za
-apps/erpnext/erpnext/stock/doctype/item/item.py +547,Attribute table is mandatory,Osobina stol je obavezno
+apps/erpnext/erpnext/stock/doctype/item/item.py +552,Attribute table is mandatory,Osobina stol je obavezno
 DocType: Production Planning Tool,Get Sales Orders,Kreiraj narudžbe
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +64,{0} can not be negative,{0} ne može biti negativna
 apps/erpnext/erpnext/public/js/pos/pos.html +28,Discount,Popust
-DocType: Features Setup,Purchase Discounts,Kupnja Popusti
+DocType: Features Setup,Purchase Discounts,Popusti pri nabavi
 DocType: Workstation,Wages,Plaće
 DocType: Time Log,Will be updated only if Time Log is 'Billable',Će se ažurirati samo ako vrijeme Log &#39;naplativo&#39;
 DocType: Project,Internal,Interni
@@ -871,23 +892,24 @@
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +97,Please specify a valid Row ID for row {0} in table {1},Navedite valjanu Row ID za redom {0} u tablici {1}
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Idi na radnu površinu i početi koristiti ERPNext
 DocType: Item,Manufacturer,Proizvođač
-DocType: Landed Cost Item,Purchase Receipt Item,Kupnja Potvrda predmet
+DocType: Landed Cost Item,Purchase Receipt Item,Stavka primke
 DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervirano Warehouse u prodajni nalog / skladišta gotovih proizvoda
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Selling Amount,Prodaja Iznos
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +79,Time Logs,Vrijeme Trupci
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +80,Time Logs,Vrijeme Trupci
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +125,You are the Expense Approver for this record. Please Update the 'Status' and Save,Vi ste osoba za odobrenje rashoda za ovaj zapis. Molimo ažurirajte status i spremite
 DocType: Serial No,Creation Document No,Stvaranje dokumenata nema
 DocType: Issue,Issue,Izdanje
+DocType: Asset,Scrapped,otpisan
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account does not match with Company,Račun ne odgovara tvrtke
 apps/erpnext/erpnext/config/stock.py +191,"Attributes for Item Variants. e.g Size, Color etc.","Atributi za stavku varijanti. npr Veličina, boja i sl"
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +39,WIP Warehouse,WIP Skladište
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +181,Serial No {0} is under maintenance contract upto {1},Serijski Ne {0} je pod ugovorom za održavanje upto {1}
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +185,Serial No {0} is under maintenance contract upto {1},Serijski Ne {0} je pod ugovorom za održavanje upto {1}
 apps/erpnext/erpnext/config/hr.py +35,Recruitment,regrutacija
 DocType: BOM Operation,Operation,Operacija
 DocType: Lead,Organization Name,Naziv organizacije
 DocType: Tax Rule,Shipping State,Državna dostava
 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 dodana pomoću 'se predmeti od kupnje primitaka' gumb
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Sales Expenses,Prodajni troškovi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Sales Expenses,Prodajni troškovi
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +106,Standard Buying,Standardna kupnju
 DocType: GL Entry,Against,Protiv
 DocType: Item,Default Selling Cost Center,Zadani trošak prodaje
@@ -904,7 +926,7 @@
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +30,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 tvrtke.
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +145,Dr,Doktor
-apps/erpnext/erpnext/config/buying.py +18,Quotations received from Suppliers.,Ponude dobivene od dobavljača.
+apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Ponude dobivene od dobavljača.
 apps/erpnext/erpnext/controllers/selling_controller.py +21,To {0} | {1} {2},Za {0} | {1} {2}
 DocType: Time Log Batch,updated via Time Logs,ažurirati putem Vrijeme Trupci
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Prosječna starost
@@ -913,7 +935,7 @@
 DocType: Company,Default Currency,Zadana valuta
 DocType: Contact,Enter designation of this Contact,Upišite oznaku ove Kontakt
 DocType: Expense Claim,From Employee,Od zaposlenika
-apps/erpnext/erpnext/controllers/accounts_controller.py +334,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
+apps/erpnext/erpnext/controllers/accounts_controller.py +347,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,Gledanost od datuma
 DocType: Appraisal Template Goal,Key Performance Area,Zona ključnih performansi
@@ -921,7 +943,7 @@
 apps/erpnext/erpnext/hr/report/monthly_salary_register/monthly_salary_register.py +67, and year: ,i godina:
 DocType: Email Digest,Annual Expense,Godišnji rashodi
 DocType: SMS Center,Total Characters,Ukupno Likovi
-apps/erpnext/erpnext/controllers/buying_controller.py +130,Please select BOM in BOM field for Item {0},Odaberite BOM u BOM polje za točku {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +131,Please select BOM in BOM field for Item {0},Odaberite BOM u BOM polje za točku {0}
 DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-obrazac detalj računa
 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%
@@ -930,22 +952,23 @@
 DocType: Sales Partner,Distributor,Distributer
 DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Košarica Dostava Rule
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +208,Production Order {0} must be cancelled before cancelling this Sales Order,Proizvodni nalog {0} mora biti poništen prije nego se poništi ova prodajna narudžba
-apps/erpnext/erpnext/public/js/controllers/transaction.js +930,Please set 'Apply Additional Discount On',Molimo postavite &quot;Primijeni dodatni popust na &#39;
+apps/erpnext/erpnext/public/js/controllers/transaction.js +941,Please set 'Apply Additional Discount On',Molimo postavite &quot;Primijeni dodatni popust na &#39;
 ,Ordered Items To Be Billed,Naručeni proizvodi za naplatu
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +24,From Range has to be less than To Range,Od Raspon mora biti manji od u rasponu
 apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +21,Select Time Logs and Submit to create a new Sales Invoice.,Odaberite vrijeme Evidencije i slanje stvoriti novi prodajni fakture.
 DocType: Global Defaults,Global Defaults,Globalne zadane postavke
+apps/erpnext/erpnext/projects/doctype/project/project.py +144,Project Collaboration Invitation,Projekt Suradnja Poziv
 DocType: Salary Slip,Deductions,Odbici
 apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +23,This Time Log Batch has been billed.,Ovo Batch Vrijeme Log je naplaćeno.
 DocType: Salary Slip,Leave Without Pay,Neplaćeno odsustvo
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +297,Capacity Planning Error,Kapacitet Greška planiranje
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +270,Capacity Planning Error,Kapacitet Greška planiranje
 ,Trial Balance for Party,Suđenje Stanje na stranku
 DocType: Lead,Consultant,Konzultant
 DocType: Salary Slip,Earnings,Zarada
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Finished Item {0} must be entered for Manufacture type entry,Gotovi Stavka {0} mora biti upisana za tip Proizvodnja upis
 apps/erpnext/erpnext/config/learn.py +92,Opening Accounting Balance,Otvaranje Računovodstvo Stanje
 DocType: Sales Invoice Advance,Sales Invoice Advance,Predujam prodajnog računa
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +473,Nothing to request,Ništa za zatražiti
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +476,Nothing to request,Ništa za zatražiti
 apps/erpnext/erpnext/projects/doctype/task/task.py +38,'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 +75,Management,Uprava
 apps/erpnext/erpnext/config/projects.py +45,Types of activities for Time Sheets,Vrste aktivnosti za vrijeme listova
@@ -956,24 +979,24 @@
 DocType: Purchase Invoice,Is Return,Je li povratak
 DocType: Price List Country,Price List Country,Država cjenika
 apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +123,Further nodes can be only created under 'Group' type nodes,"Daljnje čvorovi mogu se samo stvorio pod ""Grupa"" tipa čvorova"
-apps/erpnext/erpnext/utilities/doctype/contact/contact.py +67,Please set Email ID,Molimo postavite e-ID
+apps/erpnext/erpnext/utilities/doctype/contact/contact.py +69,Please set Email ID,Molimo postavite e-ID
 DocType: Item,UOMs,J. MJ.
 apps/erpnext/erpnext/stock/utils.py +171,{0} valid serial nos for Item {1},{0} valjani serijski nos za Stavka {1}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Kod proizvoda ne može se mijenjati za serijski broj.
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +22,POS Profile {0} already created for user: {1} and company {2},POS Profil {0} je već stvoren za korisnika: {1} i društvo {2}
 DocType: Purchase Order Item,UOM Conversion Factor,UOM konverzijski faktor
 DocType: Stock Settings,Default Item Group,Zadana grupa proizvoda
-apps/erpnext/erpnext/config/buying.py +33,Supplier database.,Dobavljač baza podataka.
+apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Dobavljač baza podataka.
 DocType: Account,Balance Sheet,Završni račun
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +580,Cost Center For Item with Item Code ',Troška za stavku s šifra '
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +623,Cost Center For Item with Item Code ',Troška za stavku s šifra '
 DocType: Opportunity,Your sales person will get a reminder on this date to contact the customer,Prodavač će dobiti podsjetnik na taj datum kako bi pravovremeno kontaktirao kupca
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +209,"Further accounts can be made under Groups, but entries can be made against non-Groups","Daljnje računi mogu biti u skupinama, ali unose se može podnijeti protiv nesrpskog Groups"
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +212,"Further accounts can be made under Groups, but entries can be made against non-Groups","Daljnje računi mogu biti u skupinama, ali unose se može podnijeti protiv nesrpskog Groups"
 apps/erpnext/erpnext/config/hr.py +120,Tax and other salary deductions.,Porez i drugih isplata plaća.
 DocType: Lead,Lead,Potencijalni kupac
 DocType: Email Digest,Payables,Plativ
 DocType: Account,Warehouse,Skladište
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +83,Row #{0}: Rejected Qty can not be entered in Purchase Return,Red # {0}: Odbijen Kom se ne može upisati u kupnju povratak
-,Purchase Order Items To Be Billed,Narudžbenica Proizvodi se naplaćuje
+,Purchase Order Items To Be Billed,Stavke narudžbenice za naplatu
 DocType: Purchase Invoice Item,Net Rate,Neto stopa
 DocType: Purchase Invoice Item,Purchase Invoice Item,Proizvod ulaznog računa
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +50,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Upisi u glavnu knjigu i GL upisi su ponovno postavljeni za odabrane primke.
@@ -981,6 +1004,7 @@
 DocType: Holiday,Holiday,Odmor
 DocType: Leave Control Panel,Leave blank if considered for all branches,Ostavite prazno ako se odnosi na sve poslovnice
 ,Daily Time Log Summary,Dnevno vrijeme Log Profila
+apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-oblika nije primjenjiv za fakture: {0}
 DocType: Payment Reconciliation,Unreconciled Payment Details,Nesaglašen Detalji plaćanja
 DocType: Global Defaults,Current Fiscal Year,Tekuće fiskalne godine
 DocType: Global Defaults,Disable Rounded Total,Ugasiti zaokruženi iznos
@@ -994,19 +1018,20 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +138,Research,istraživanje
 DocType: Maintenance Visit Purpose,Work Done,Rad Done
 apps/erpnext/erpnext/controllers/item_variant.py +25,Please specify at least one attribute in the Attributes table,Navedite barem jedan atribut u tablici Svojstva
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +33,Item {0} must be a non-stock item,Stavka {0} mora biti ne-stock točka a
 DocType: Contact,User ID,Korisnički ID
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +128,View Ledger,Pogledaj Ledger
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +131,View Ledger,Pogledaj Ledger
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Najstarije
-apps/erpnext/erpnext/stock/doctype/item/item.py +431,"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/stock/doctype/item/item.py +436,"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: Production Order,Manufacture against Sales Order,Proizvodnja protiv prodaje Reda
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +412,Rest Of The World,Ostatak svijeta
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +83,The Item {0} cannot have Batch,Stavka {0} ne može imati Hrpa
 ,Budget Variance Report,Proračun varijance Prijavi
 DocType: Salary Slip,Gross Pay,Bruto plaća
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +186,Dividends Paid,Plaćeni Dividende
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +189,Dividends Paid,Plaćeni Dividende
 apps/erpnext/erpnext/public/js/controllers/stock_controller.js +40,Accounting Ledger,Računovodstvo knjiga
 DocType: Stock Reconciliation,Difference Amount,Razlika Količina
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +192,Retained Earnings,Zadržana dobit
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +195,Retained Earnings,Zadržana dobit
 DocType: BOM Item,Item Description,Opis proizvoda
 DocType: Payment Tool,Payment Mode,Način plaćanja
 DocType: Purchase Invoice,Is Recurring,Je Ponavljajući
@@ -1014,7 +1039,7 @@
 DocType: Production Order,Qty To Manufacture,Količina za proizvodnju
 DocType: Buying Settings,Maintain same rate throughout purchase cycle,Održavaj istu stopu tijekom cijelog ciklusa kupnje
 DocType: Opportunity Item,Opportunity Item,Prilika proizvoda
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Temporary Opening,Privremeni Otvaranje
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +64,Temporary Opening,Privremeni Otvaranje
 ,Employee Leave Balance,Zaposlenik napuste balans
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +127,Balance for Account {0} must always be {1},Bilanca računa {0} uvijek mora biti {1}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +179,Valuation Rate required for Item in row {0},Procjena stopa potrebna za stavke u retku {0}
@@ -1029,8 +1054,8 @@
 ,Accounts Payable Summary,Obveze Sažetak
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +192,Not authorized to edit frozen Account {0},Niste ovlašteni za uređivanje zamrznutog računa {0}
 DocType: Journal Entry,Get Outstanding Invoices,Kreiraj neplaćene račune
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +63,Sales Order {0} is not valid,Prodajnog naloga {0} nije ispravan
-apps/erpnext/erpnext/setup/doctype/company/company.py +165,"Sorry, companies cannot be merged","Žao nam je , tvrtke ne mogu spojiti"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +65,Sales Order {0} is not valid,Prodajnog naloga {0} nije ispravan
+apps/erpnext/erpnext/setup/doctype/company/company.py +168,"Sorry, companies cannot be merged","Žao nam je , tvrtke ne mogu spojiti"
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +126,"The total Issue / Transfer quantity {0} in Material Request {1}  \
 							cannot be greater than requested quantity {2} for Item {3}",Ukupna količina Pitanje / Prijenos {0} u materijalnim Zahtjevu {1} \ ne može biti veća od tražene količine {2} za točki {3}
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +145,Small,Mali
@@ -1038,7 +1063,7 @@
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +65,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}
 ,Invoiced Amount (Exculsive Tax),Dostavljeni iznos ( Exculsive poreza )
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Stavka 2
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +59,Account head {0} created,Zaglavlje računa {0} stvoreno
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +67,Account head {0} created,Zaglavlje računa {0} stvoreno
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +153,Green,Zelena
 DocType: Item,Auto re-order,Auto re-red
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Ukupno Ostvareno
@@ -1046,12 +1071,12 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +59,Contract,ugovor
 DocType: Email Digest,Add Quote,Dodaj ponudu
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +493,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 +83,Indirect Expenses,Neizravni troškovi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +86,Indirect Expenses,Neizravni troškovi
 apps/erpnext/erpnext/controllers/selling_controller.py +163,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/public/js/setup_wizard.js +257,Your Products or Services,Vaši proizvodi ili usluge
 DocType: Mode of Payment,Mode of Payment,Način plaćanja
-apps/erpnext/erpnext/stock/doctype/item/item.py +121,Website Image should be a public file or website URL,Web slika bi trebala biti javna datoteke ili URL web stranice
+apps/erpnext/erpnext/stock/doctype/item/item.py +126,Website Image should be a public file or website URL,Web slika bi trebala biti javna datoteke ili URL web stranice
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +31,This is a root item group and cannot be edited.,To jekorijen stavka grupa i ne može se mijenjati .
 DocType: Journal Entry Account,Purchase Order,Narudžbenica
 DocType: Warehouse,Warehouse Contact Info,Kontakt informacije skladišta
@@ -1061,19 +1086,20 @@
 DocType: Serial No,Serial No Details,Serijski nema podataka
 DocType: Purchase Invoice Item,Item Tax Rate,Porezna stopa proizvoda
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,"For {0}, only credit accounts can be linked against another debit entry","Za {0}, samo kreditne računi se mogu povezati protiv drugog ulaska debitnom"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +482,Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena
-apps/erpnext/erpnext/stock/get_item_details.py +143,Item {0} must be a Sub-contracted Item,Stavka {0} mora bitisklopljen ugovor artikla
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +486,Delivery Note {0} is not submitted,Otpremnica {0} nije potvrđena
+apps/erpnext/erpnext/stock/get_item_details.py +142,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 +41,Capital Equipments,Kapitalni oprema
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +31,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Cijene Pravilo prvo se bira na temelju 'Nanesite na' terenu, koji može biti točka, točka Grupa ili Brand."
 DocType: Hub Settings,Seller Website,Web Prodavač
 apps/erpnext/erpnext/controllers/selling_controller.py +143,Total allocated percentage for sales team should be 100,Ukupno dodijeljeno postotak za prodajni tim bi trebao biti 100
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +111,Production Order status is {0},Status proizvodnog naloga je {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +113,Production Order status is {0},Status proizvodnog naloga je {0}
 DocType: Appraisal Goal,Goal,Cilj
 DocType: Sales Invoice Item,Edit Description,Uredi Opis
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +329,Expected Delivery Date is lesser than Planned Start Date.,Očekivani isporuke Datum manji od planiranog početka Datum.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +750,For Supplier,za Supplier
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +331,Expected Delivery Date is lesser than Planned Start Date.,Očekivani isporuke Datum manji od planiranog početka Datum.
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +617,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/utilities/bot.py +39,Did not find any item called {0},Niste pronašli bilo koju stavku pod nazivom {0}
 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 +48,"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
@@ -1081,10 +1107,10 @@
 DocType: Item,Website Item Groups,Grupe proizvoda web stranice
 DocType: Purchase Invoice,Total (Company Currency),Ukupno (Društvo valuta)
 apps/erpnext/erpnext/stock/utils.py +166,Serial number {0} entered more than once,Serijski broj {0} ušao više puta
-DocType: Journal Entry,Journal Entry,Temeljnica
+DocType: Depreciation Schedule,Journal Entry,Temeljnica
 DocType: Workstation,Workstation Name,Ime Workstation
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,E-pošta:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +433,BOM {0} does not belong to Item {1},BOM {0} ne pripada Točki {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +442,BOM {0} does not belong to Item {1},BOM {0} ne pripada Točki {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
@@ -1093,6 +1119,7 @@
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +74,"Total {0} for all items is zero, may you should change 'Distribute Charges Based On'","Ukupno {0} za sve stavke nula, možda biste trebali promijeniti &quot;Podijeliti optužbi na temelju &#39;"
 DocType: Purchase Invoice,Taxes and Charges Calculation,Porezi i naknade Proračun
 DocType: BOM Operation,Workstation,Radna stanica
+DocType: Request for Quotation Supplier,Request for Quotation Supplier,Zahtjev za ponudu dobavljača
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +112,Hardware,Hardver
 DocType: Sales Order,Recurring Upto,ponavljajući Upto
 DocType: Attendance,HR Manager,HR menadžer
@@ -1103,6 +1130,7 @@
 DocType: Appraisal Template Goal,Appraisal Template Goal,Procjena Predložak cilja
 DocType: Salary Slip,Earning,Zarada
 DocType: Payment Tool,Party Account Currency,Strana valuta računa
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +46,Current Value After Depreciation must be less than equal to {0},Trenutna vrijednost nakon amortizacije mora biti manja od jednaka {0}
 ,BOM Browser,BOM preglednik
 DocType: Purchase Taxes and Charges,Add or Deduct,Zbrajanje ili oduzimanje
 DocType: Company,If Yearly Budget Exceeded (for expense account),Ako Godišnji proračun Prebačen (za reprezentaciju)
@@ -1117,21 +1145,22 @@
 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},Zbroj bodova svih ciljeva trebao biti 100. To je {0}
 DocType: Project,Start and End Dates,Datumi početka i završetka
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +366,Operations cannot be left blank.,Operacije se ne može ostati prazno.
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +375,Operations cannot be left blank.,Operacije se ne može ostati prazno.
 ,Delivered Items To Be Billed,Isporučeni proizvodi za naplatiti
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Skladište se ne može promijeniti za serijskog broja
 DocType: Authorization Rule,Average Discount,Prosječni popust
 DocType: Address,Utilities,Komunalne usluge
 DocType: Purchase Invoice Item,Accounting,Knjigovodstvo
 DocType: Features Setup,Features Setup,Značajke postavki
+DocType: Asset,Depreciation Schedules,amortizacija Raspored
 DocType: Item,Is Service Item,Je usluga
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +84,Application period cannot be outside leave allocation period,Razdoblje prijava ne može biti izvan dopusta raspodjele
 DocType: Activity Cost,Projects,Projekti
 DocType: Payment Request,Transaction Currency,transakcija valuta
-apps/erpnext/erpnext/controllers/buying_controller.py +23,From {0} | {1} {2},Od {0} | {1} {2}
+apps/erpnext/erpnext/controllers/buying_controller.py +24,From {0} | {1} {2},Od {0} | {1} {2}
 DocType: BOM Operation,Operation Description,Operacija Opis
 DocType: Item,Will also apply to variants,Također će se primjenjivati na varijanti
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +31,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Ne možete promijeniti fiskalnu godinu datum početka i datum završetka fiskalne godine kada Fiskalna godina se sprema.
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +32,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Ne možete promijeniti fiskalnu godinu datum početka i datum završetka fiskalne godine kada Fiskalna godina se sprema.
 DocType: Quotation,Shopping Cart,Košarica
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Prosječni dnevni izlaz
 DocType: Pricing Rule,Campaign,Kampanja
@@ -1145,8 +1174,8 @@
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +210,Stock Entries already created for Production Order ,Stock Prijave su već stvorene za proizvodnju reda
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +31,Net Change in Fixed Asset,Neto promjena u dugotrajne imovine
 DocType: Leave Control Panel,Leave blank if considered for all designations,Ostavite prazno ako se odnosi na sve oznake
-apps/erpnext/erpnext/controllers/accounts_controller.py +513,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 +181,Max: {0},Maksimalno: {0}
+apps/erpnext/erpnext/controllers/accounts_controller.py +539,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 +182,Max: {0},Maksimalno: {0}
 apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +16,From Datetime,Od datetime
 DocType: Email Digest,For Company,Za tvrtke
 apps/erpnext/erpnext/config/support.py +17,Communication log.,Dnevnik mailova
@@ -1154,13 +1183,13 @@
 DocType: Sales Invoice,Shipping Address Name,Dostava Adresa Ime
 apps/erpnext/erpnext/accounts/doctype/account/account.js +50,Chart of Accounts,Kontni plan
 DocType: Material Request,Terms and Conditions Content,Uvjeti sadržaj
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +472,cannot be greater than 100,ne može biti veće od 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +583,Item {0} is not a stock Item,Proizvod {0} nije skladišni proizvod
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +475,cannot be greater than 100,ne može biti veće od 100
+apps/erpnext/erpnext/stock/doctype/item/item.py +592,Item {0} is not a stock Item,Proizvod {0} nije skladišni proizvod
 DocType: Maintenance Visit,Unscheduled,Neplanski
 DocType: Employee,Owned,U vlasništvu
 DocType: Salary Slip Deduction,Depends on Leave Without Pay,Ovisi o ostaviti bez platiti
 DocType: Pricing Rule,"Higher the number, higher the priority","Veći broj, veći prioritet"
-,Purchase Invoice Trends,Trendovi kupnje proizvoda
+,Purchase Invoice Trends,Trendovi nabavnih računa
 DocType: Employee,Better Prospects,Bolji izgledi
 DocType: Appraisal,Goals,Golovi
 DocType: Warranty Claim,Warranty / AMC Status,Jamstveni / AMC Status
@@ -1177,11 +1206,11 @@
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +156,Employee cannot report to himself.,Zaposlenik se ne može prijaviti na 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,Bankovni saldo
-apps/erpnext/erpnext/controllers/accounts_controller.py +447,Accounting Entry for {0}: {1} can only be made in currency: {2},Računovodstvo Ulaz za {0}: {1} može biti samo u valuti: {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +460,Accounting Entry for {0}: {1} can only be made in currency: {2},Računovodstvo Ulaz za {0}: {1} može biti samo u valuti: {2}
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +44,No active Salary Structure found for employee {0} and the month,Ne aktivna Struktura plaća pronađenih zaposlenika {0} i mjesec
 DocType: Job Opening,"Job profile, qualifications required etc.","Profil posla, tražene kvalifikacije i sl."
 DocType: Journal Entry Account,Account Balance,Bilanca računa
-apps/erpnext/erpnext/config/accounts.py +167,Tax Rule for transactions.,Porezni Pravilo za transakcije.
+apps/erpnext/erpnext/config/accounts.py +175,Tax Rule for transactions.,Porezni Pravilo za transakcije.
 DocType: Rename Tool,Type of document to rename.,Vrsta dokumenta za promjenu naziva.
 apps/erpnext/erpnext/public/js/setup_wizard.js +276,We buy this Item,Kupili smo ovaj proizvod
 DocType: Address,Billing,Naplata
@@ -1191,12 +1220,15 @@
 DocType: Quality Inspection,Readings,Očitanja
 DocType: Stock Entry,Total Additional Costs,Ukupno Dodatni troškovi
 apps/erpnext/erpnext/public/js/setup_wizard.js +269,Sub Assemblies,pod skupštine
+DocType: Asset,Asset Name,Naziv imovinom
 DocType: Shipping Rule Condition,To Value,Za vrijednost
 DocType: Supplier,Stock Manager,Stock Manager
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +142,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 +600,Packing Slip,Odreskom
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Office Rent,Najam ureda
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +643,Packing Slip,Odreskom
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +114,Office Rent,Najam ureda
 apps/erpnext/erpnext/config/setup.py +110,Setup SMS gateway settings,Postavke SMS pristupnika
+apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,Request for quotation can be access by clicking following link,Zahtjev za ponudu može biti pristup klikom linku
+DocType: Asset,Number of Months in a Period,Broj mjeseci u razdoblju
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +60,Import Failed!,Uvoz nije uspio !
 apps/erpnext/erpnext/public/js/templates/address_list.html +21,No address added yet.,Adresa još nije dodana.
 DocType: Workstation Working Hour,Workstation Working Hour,Workstation Radno vrijeme
@@ -1213,28 +1245,29 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +105,Government,Vlada
 apps/erpnext/erpnext/config/stock.py +290,Item Variants,Stavka Varijante
 DocType: Company,Services,Usluge
-apps/erpnext/erpnext/accounts/report/financial_statements.py +191,Total ({0}),Ukupno ({0})
+apps/erpnext/erpnext/accounts/report/financial_statements.py +198,Total ({0}),Ukupno ({0})
 DocType: Cost Center,Parent Cost Center,Nadređeni troškovni centar
 DocType: Sales Invoice,Source,Izvor
+apps/erpnext/erpnext/templates/pages/projects.html +57,Show closed,Prikaži zatvorene
 DocType: Leave Type,Is Leave Without Pay,Je Ostavite bez plaće
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +129,No records found in the Payment table,Nisu pronađeni zapisi u tablici plaćanja
 apps/erpnext/erpnext/public/js/setup_wizard.js +39,Financial Year Start Date,Financijska godina - početni datum
 DocType: Employee External Work History,Total Experience,Ukupno Iskustvo
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +261,Packing Slip(s) cancelled,Pakiranje proklizavanja ( s) otkazan
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29,Cash Flow from Investing,Novčani tijek iz investicijskih
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +96,Freight and Forwarding Charges,Teretni i Forwarding Optužbe
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Teretni i Forwarding Optužbe
 DocType: Item Group,Item Group Name,Proizvod - naziv grupe
 apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Taken
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +86,Transfer Materials for Manufacture,Prijenos Materijali za izradu
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +87,Transfer Materials for Manufacture,Prijenos Materijali za izradu
 DocType: Pricing Rule,For Price List,Za cjenik
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Executive Search
-apps/erpnext/erpnext/stock/stock_ledger.py +406,"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.","Kupnja stopa za stavke: {0} nije pronađena, koja je potrebna za rezervaciju knjiženje (trošak). Molimo spomenuti predmet cijenu od popisa za kupnju cijena."
+apps/erpnext/erpnext/stock/stock_ledger.py +406,"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.","Nabavna cijena za stavke: {0} nije pronađena, a potrebna je za knjiženje (trošak). Molimo unesite cijenu stavke prema popisu nabavnnih cijena."
 DocType: Maintenance Schedule,Schedules,Raspored
 DocType: Purchase Invoice Item,Net Amount,Neto Iznos
 DocType: Purchase Order Item Supplied,BOM Detail No,BOM detalji - broj
 DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatni popust Iznos (valuta Društvo)
 apps/erpnext/erpnext/accounts/doctype/account/account.js +8,Please create new account from Chart of Accounts.,Kreirajte novi račun iz kontnog plana.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +659,Maintenance Visit,Održavanje Posjetite
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +702,Maintenance Visit,Održavanje Posjetite
 DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Dostupno Batch Količina na skladištu
 DocType: Time Log Batch Detail,Time Log Batch Detail,Vrijeme Log Batch Detalj
 DocType: Landed Cost Voucher,Landed Cost Help,Zavisni troškovi - Pomoć
@@ -1248,7 +1281,6 @@
 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 vrijednost zaliha u sustavu. To se obično koristi za sinkronizaciju vrijednosti sustava i što se zapravo postoji u svojim skladištima.
 DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,Riječima će biti vidljivo nakon što spremite otpremnicu.
 apps/erpnext/erpnext/config/stock.py +196,Brand master.,Glavni brend.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +52,Supplier &gt; Supplier Type,Dobavljač&gt; Vrsta Dobavljač
 DocType: Sales Invoice Item,Brand Name,Naziv brenda
 DocType: Purchase Receipt,Transporter Details,Transporter Detalji
 apps/erpnext/erpnext/public/js/setup_wizard.js +272,Box,kutija
@@ -1276,7 +1308,7 @@
 DocType: Quality Inspection Reading,Reading 4,Čitanje 4
 apps/erpnext/erpnext/config/hr.py +131,Claims for company expense.,Potraživanja za tvrtke trošak.
 DocType: Company,Default Holiday List,Default odmor List
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +165,Stock Liabilities,Stock Obveze
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +168,Stock Liabilities,Stock Obveze
 DocType: Purchase Receipt,Supplier Warehouse,Dobavljač galerija
 DocType: Opportunity,Contact Mobile No,Kontak GSM
 ,Material Requests for which Supplier Quotations are not created,Zahtjevi za robom za koje dobavljačeve ponude nisu stvorene
@@ -1285,7 +1317,7 @@
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Ponovno slanje plaćanja Email
 apps/erpnext/erpnext/config/selling.py +210,Other Reports,Ostala izvješća
 DocType: Dependent Task,Dependent Task,Ovisno zadatak
-apps/erpnext/erpnext/stock/doctype/item/item.py +344,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 +349,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 +180,Leave of type {0} cannot be longer than {1},Odsustvo tipa {0} ne može biti duže od {1}
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,Pokušajte planirati poslovanje za X dana unaprijed.
 DocType: HR Settings,Stop Birthday Reminders,Zaustavi Rođendan Podsjetnici
@@ -1295,26 +1327,27 @@
 apps/erpnext/erpnext/public/js/pos/pos.js +520,{0} View,{0} Pogledaj
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +96,Net Change in Cash,Neto promjena u gotovini
 DocType: Salary Structure Deduction,Salary Structure Deduction,Plaća Struktura Odbitak
-apps/erpnext/erpnext/stock/doctype/item/item.py +339,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/stock/doctype/item/item.py +344,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/accounts/doctype/payment_request/payment_request.py +24,Payment Request already exists {0},Zahtjev za plaćanje već postoji {0}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Trošak izdanih stavki
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +184,Quantity must not be more than {0},Količina ne smije biti veća od {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +185,Quantity must not be more than {0},Količina ne smije biti veća od {0}
+apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +72,Previous Financial Year is not closed,Prethodne financijske godine nije zatvoren
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +41,Age (Days),Starost (dani)
 DocType: Quotation Item,Quotation Item,Proizvod iz ponude
 DocType: Account,Account Name,Naziv računa
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Od datuma ne može biti veća od To Date
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +194,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 +38,Supplier Type master.,Dobavljač Vrsta majstor .
+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 +93,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 +94,Conversion rate cannot be 0 or 1,Stopa pretvorbe ne može biti 0 ili 1
 DocType: Purchase Invoice,Reference Document,Referentni dokument
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +172,{0} {1} is cancelled or stopped,{0} {1} otkazan ili zaustavljen
 DocType: Accounts Settings,Credit Controller,Kreditne kontroler
 DocType: Delivery Note,Vehicle Dispatch Date,Vozilo Dispatch Datum
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +203,Purchase Receipt {0} is not submitted,Primka {0} nije potvrđena
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +205,Purchase Receipt {0} is not submitted,Primka {0} nije potvrđena
 DocType: Company,Default Payable Account,Zadana Plaća račun
-apps/erpnext/erpnext/config/website.py +13,"Settings for online shopping cart such as shipping rules, price list etc.","Postavke za online košarici, kao što su utovar pravila, cjenika i sl"
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +65,{0}% Billed,{0}% Naplaćeno
+apps/erpnext/erpnext/config/website.py +12,"Settings for online shopping cart such as shipping rules, price list etc.","Postavke za online košarici, kao što su utovar pravila, cjenika i sl"
+apps/erpnext/erpnext/controllers/website_list_for_contact.py +80,{0}% Billed,{0}% Naplaćeno
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +17,Reserved Qty,Rezervirano Kol
 DocType: Party Account,Party Account,Račun stranke
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +74,Human Resources,Ljudski resursi
@@ -1336,8 +1369,9 @@
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +21,Net Change in Accounts Payable,Neto promjena u obveze prema dobavljačima
 apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +137,Please verify your email id,Molimo provjerite svoj e-id
 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 +129,Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.
+apps/erpnext/erpnext/config/accounts.py +137,Update bank payment dates with journals.,Update banka datum plaćanja s časopisima.
 DocType: Quotation,Term Details,Oročeni Detalji
+apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} mora biti veći od 0
 DocType: Manufacturing Settings,Capacity Planning For (Days),Planiranje kapaciteta za (dani)
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +63,None of the items have any change in quantity or value.,Nitko od stavki ima bilo kakve promjene u količini ili vrijednosti.
 apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +30,Warranty Claim,Jamstvo Zatraži
@@ -1355,7 +1389,7 @@
 DocType: Employee,Permanent Address,Stalna adresa
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +233,"Advance paid against {0} {1} cannot be greater \
 						than Grand Total {2}",Unaprijed plaćeni od {0} {1} ne može biti veća \ nego SVEUKUPNO {2}
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +135,Please select item code,Odaberite Šifra
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +139,Please select item code,Odaberite Šifra
 DocType: Salary Structure Deduction,Reduce Deduction for Leave Without Pay (LWP),Smanjite odbitak za ostaviti bez plaća (lwp)
 DocType: Territory,Territory Manager,Upravitelj teritorija
 DocType: Packed Item,To Warehouse (Optional),Za Warehouse (po izboru)
@@ -1365,15 +1399,15 @@
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +39,Online Auctions,Online aukcije
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +101,Please specify either Quantity or Valuation Rate or both,Navedite ili količini ili vrednovanja Ocijenite ili oboje
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +50,"Company, Month and Fiscal Year is mandatory","Tvrtka , Mjesec i Fiskalna godina je obvezno"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Marketing Expenses,Troškovi marketinga
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +105,Marketing Expenses,Troškovi marketinga
 ,Item Shortage Report,Nedostatak izvješća za proizvod
-apps/erpnext/erpnext/stock/doctype/item/item.js +194,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Težina se spomenuto, \n Molimo spomenuti ""težinu UOM"" previše"
+apps/erpnext/erpnext/stock/doctype/item/item.js +181,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Težina se spomenuto, \n Molimo spomenuti ""težinu UOM"" previše"
 DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Zahtjev za robom korišten za izradu ovog ulaza robe
 apps/erpnext/erpnext/config/support.py +53,Single unit of an Item.,Jedna jedinica stavku.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +215,Time Log Batch {0} must be 'Submitted',"Vrijeme Log Batch {0} mora biti "" Postavio '"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +216,Time Log Batch {0} must be 'Submitted',"Vrijeme Log Batch {0} mora biti "" Postavio '"
 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/sales_invoice/sales_invoice.py +392,Warehouse required at Row No {0},Skladište potrebna u nizu br {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +385,Warehouse required at Row No {0},Skladište potrebna u nizu br {0}
 apps/erpnext/erpnext/public/js/setup_wizard.js +55,Please enter valid Financial Year Start and End Dates,Unesite valjani financijske godine datum početka i kraja
 DocType: Employee,Date Of Retirement,Datum odlaska u mirovinu
 DocType: Upload Attendance,Get Template,Kreiraj predložak
@@ -1390,33 +1424,35 @@
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +48,Party Type and Party is required for Receivable / Payable account {0},Party Tip i stranka je potrebna za potraživanja / obveze prema dobavljačima račun {0}
 DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ako ova stavka ima varijante, onda to ne može biti izabran u prodajnim nalozima itd"
 DocType: Lead,Next Contact By,Sljedeći kontakt od
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +216,Quantity required for Item {0} in row {1},Količina potrebna za proizvod {0} u redku {1}
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +85,Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti izbrisano ako na njemu ima proizvod {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +225,Quantity required for Item {0} in row {1},Količina potrebna za proizvod {0} u redku {1}
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +93,Warehouse {0} can not be deleted as quantity exists for Item {1},Skladište {0} ne može biti izbrisano ako na njemu ima proizvod {1}
 DocType: Quotation,Order Type,Vrsta narudžbe
 DocType: Purchase Invoice,Notification Email Address,Obavijest E-mail adresa
 DocType: Payment Tool,Find Invoices to Match,Nađi račune kako bi se slagala
 ,Item-wise Sales Register,Stavka-mudri prodaja registar
+DocType: Asset,Gross Purchase Amount,Bruto Iznos narudžbe
 apps/erpnext/erpnext/public/js/setup_wizard.js +24,"e.g. ""XYZ National Bank""","npr ""XYZ narodna banka """
+DocType: Asset,Depreciation Method,Metoda amortizacije
 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 +61,Total Target,Ukupno Target
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.js +29,Shopping Cart is enabled,Košarica omogućeno
 DocType: Job Applicant,Applicant for a Job,Podnositelj zahtjeva za posao
 DocType: Production Plan Material Request,Production Plan Material Request,Izrada plana materijala Zahtjev
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +232,No Production Orders created,Nema napravljenih proizvodnih naloga
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +235,No Production Orders created,Nema napravljenih proizvodnih naloga
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +151,Salary Slip of employee {0} already created for this month,Plaća Slip zaposlenika {0} već stvorena za ovaj mjesec
 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: Sales Invoice Item,Batch No,Broj serije
 DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Dopusti višestruke prodajne naloge protiv kupca narudžbenice
-apps/erpnext/erpnext/setup/doctype/company/company.py +145,Main,Glavni
+apps/erpnext/erpnext/setup/doctype/company/company.py +147,Main,Glavni
 apps/erpnext/erpnext/stock/doctype/item/item.js +53,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,Zaposlenici HTML
-apps/erpnext/erpnext/stock/doctype/item/item.py +361,Default BOM ({0}) must be active for this item or its template,Zadana BOM ({0}) mora biti aktivan za tu stavku ili njegov predložak
+apps/erpnext/erpnext/stock/doctype/item/item.py +366,Default BOM ({0}) must be active for this item or its template,Zadana BOM ({0}) mora biti aktivan za tu stavku ili njegov predložak
 DocType: Employee,Leave Encashed?,Odsustvo naplaćeno?
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Prilika Od polje je obavezno
 DocType: Item,Variants,Varijante
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +759,Make Purchase Order,Napravi narudžbu kupnje
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +802,Make Purchase Order,Napravi narudžbu kupnje
 DocType: SMS Center,Send To,Pošalji
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +131,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,Dodijeljeni iznos
@@ -1424,31 +1460,32 @@
 DocType: Sales Invoice Item,Customer's Item Code,Kupca Stavka Šifra
 DocType: Stock Reconciliation,Stock Reconciliation,Kataloški pomirenje
 DocType: Territory,Territory Name,Naziv teritorija
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +152,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 +154,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 reference
 DocType: Supplier,Statutory info and other general information about your Supplier,Zakonska info i druge opće informacije o vašem Dobavljaču
-apps/erpnext/erpnext/shopping_cart/utils.py +37,Addresses,Adrese
+apps/erpnext/erpnext/hooks.py +91,Addresses,Adrese
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +142,Against Journal Entry {0} does not have any unmatched {1} entry,Protiv Temeljnica {0} nema premca {1} unos
 apps/erpnext/erpnext/config/hr.py +141,Appraisals,procjene
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,Duplicate Serial No entered for Item {0},Dupli serijski broj unešen za proizvod {0}
 DocType: Shipping Rule Condition,A condition for a Shipping Rule,Uvjet za pravilu dostava
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +337,Item is not allowed to have Production Order.,Stavka ne smije imati proizvodni nalog.
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Item is not allowed to have Production Order.,Stavka ne smije imati proizvodni nalog.
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +147,Please set filter based on Item or Warehouse,Molimo postavite filter na temelju stavka 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,Za isporuku i Bill
 DocType: GL Entry,Credit Amount in Account Currency,Kreditna Iznos u valuti računa
 apps/erpnext/erpnext/config/manufacturing.py +27,Time Logs for manufacturing.,Vrijeme Trupci za proizvodnju.
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +430,BOM {0} must be submitted,BOM {0} mora biti podnesen
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +439,BOM {0} must be submitted,BOM {0} mora biti podnesen
 DocType: Authorization Control,Authorization Control,Kontrola autorizacije
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +92,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Red # {0}: Odbijen Skladište je obvezna protiv odbijena točka {1}
 apps/erpnext/erpnext/config/projects.py +35,Time Log for tasks.,Vrijeme Prijava za zadatke.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +595,Payment,Uplata
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +598,Payment,Uplata
 DocType: Production Order Operation,Actual Time and Cost,Stvarnog vremena i troškova
 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},Zahtjev za robom od maksimalnih {0} može biti napravljen za proizvod {1} od narudžbe kupca {2}
 DocType: Employee,Salutation,Pozdrav
 DocType: Pricing Rule,Brand,Brend
 DocType: Item,Will also apply for variants,Također će podnijeti zahtjev za varijante
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +91,"Asset cannot be cancelled, as it is already {0}","Imovina se ne može otkazati, jer je već {0}"
 apps/erpnext/erpnext/config/stock.py +72,Bundle items at time of sale.,Hrpa proizvoda u vrijeme prodaje.
 DocType: Quotation Item,Actual Qty,Stvarna kol
 DocType: Sales Invoice Item,References,Reference
@@ -1459,6 +1496,7 @@
 apps/erpnext/erpnext/controllers/item_variant.py +66,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values,Vrijednost {0} za Osobina {1} ne postoji u popisu važeće točke vrijednosti atributa
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +87,Associate,pomoćnik
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Proizvod {0} nije serijalizirani proizvod
+DocType: Request for Quotation Supplier,Send Email to Supplier,Pošaljite e-poštu Dobavljaču
 DocType: SMS Center,Create Receiver List,Stvaranje Receiver popis
 DocType: Packing Slip,To Package No.,Za Paket br
 DocType: Production Planning Tool,Material Requests,Materijal Zahtjevi
@@ -1476,7 +1514,7 @@
 DocType: Sales Order Item,Delivery Warehouse,Isporuka Skladište
 DocType: Stock Settings,Allowance Percent,Dodatak posto
 DocType: SMS Settings,Message Parameter,Parametri poruke
-apps/erpnext/erpnext/config/accounts.py +192,Tree of financial Cost Centers.,Drvo centara financijski trošak.
+apps/erpnext/erpnext/config/accounts.py +200,Tree of financial Cost Centers.,Drvo centara financijski trošak.
 DocType: Serial No,Delivery Document No,Dokument isporuke br
 DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Se predmeti od kupnje primitke
 DocType: Serial No,Creation Date,Datum stvaranja
@@ -1508,41 +1546,43 @@
 ,Amount to Deliver,Iznos za isporuku
 apps/erpnext/erpnext/public/js/setup_wizard.js +266,A Product or Service,Proizvod ili usluga
 DocType: Naming Series,Current Value,Trenutna vrijednost
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +230,{0} created,{0} stvorio
+apps/erpnext/erpnext/controllers/accounts_controller.py +226,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Više fiskalne godine postoji za sada {0}. Molimo postavite tvrtka u fiskalnoj godini
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +233,{0} created,{0} stvorio
 DocType: Delivery Note Item,Against Sales Order,Protiv prodajnog naloga
 ,Serial No Status,Status serijskog broja
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +448,Item table can not be blank,Tablica ne može biti prazna
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +125,"Row {0}: To set {1} periodicity, difference between from and to date \
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +129,"Row {0}: To set {1} periodicity, difference between from and to date \
 						must be greater than or equal to {2}","Red {0}: Za postavljanje {1} periodičnost, razlika između od a do danas \
  mora biti veći ili jednak {2}"
 DocType: Pricing Rule,Selling,Prodaja
 DocType: Employee,Salary Information,Informacije o plaći
 DocType: Sales Person,Name and Employee ID,Ime i ID zaposlenika
-apps/erpnext/erpnext/accounts/party.py +271,Due Date cannot be before Posting Date,Datum dospijeća ne može biti prije datuma objavljivanja
+apps/erpnext/erpnext/accounts/party.py +277,Due Date cannot be before Posting Date,Datum dospijeća ne može biti prije datuma objavljivanja
 DocType: Website Item Group,Website Item Group,Grupa proizvoda web stranice
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +170,Duties and Taxes,Carine i porezi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +173,Duties and Taxes,Carine i porezi
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +326,Please enter Reference date,Unesite Referentni datum
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +33,Payment Gateway Account is not configured,Payment Gateway račun nije konfiguriran
 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} unosa plaćanja ne može se filtrirati po {1}
 DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tablica za proizvode koji će biti prikazani na web stranici
 DocType: Purchase Order Item Supplied,Supplied Qty,Isporučena količina
-DocType: Production Order,Material Request Item,Zahtjev za robom - proizvod
+DocType: Request for Quotation Item,Material Request Item,Zahtjev za robom - proizvod
 apps/erpnext/erpnext/config/stock.py +85,Tree of Item Groups.,Stablo grupe proizvoda.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +100,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
-,Item-wise Purchase History,Stavka-mudar Kupnja Povijest
+DocType: Asset,Sold,prodan
+,Item-wise Purchase History,Povjest nabave po stavkama
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +152,Red,Crvena
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +215,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}"
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Molimo kliknite na ""Generiraj raspored ' dohvatiti Serial No dodao je za točku {0}"
 DocType: Account,Frozen,Zaleđeni
 ,Open Production Orders,Otvoreni radni nalozi
 DocType: Installation Note,Installation Time,Vrijeme instalacije
 DocType: Sales Invoice,Accounting Details,Računovodstvo Detalji
 apps/erpnext/erpnext/setup/doctype/company/company.js +66,Delete all the Transactions for this Company,Izbrišite sve transakcije za ovu Društvo
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Red # {0}: {1} Operacija nije završeno za {2} kom gotovih proizvoda u proizvodnji Naručite # {3}. Molimo ažurirati status rada preko Vrijeme Trupci
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +57,Investments,Investicije
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +60,Investments,Investicije
 DocType: Issue,Resolution Details,Rezolucija o Brodu
 apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,izdvajanja
 DocType: Quality Inspection Reading,Acceptance Criteria,Kriterij prihvaćanja
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +160,Please enter Material Requests in the above table,Unesite materijala zahtjeva u gornjoj tablici
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +163,Please enter Material Requests in the above table,Unesite materijala zahtjeva u gornjoj tablici
 DocType: Item Attribute,Attribute Name,Ime atributa
 DocType: Item Group,Show In Website,Pokaži na web stranici
 apps/erpnext/erpnext/public/js/setup_wizard.js +267,Group,Grupa
@@ -1550,6 +1590,7 @@
 ,Qty to Order,Količina za narudžbu
 DocType: Features Setup,"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Product Bundle, Sales Order, Serial No","Za praćenje robne marke u sljedećim dokumentima izdatnice, Prilika, materijala zahtjev, točke, narudžbenice, Kupnja bon, kupac primitka, citat, prodaja faktura, proizvoda Snop, prodajni nalog, serijski broj"
 apps/erpnext/erpnext/config/projects.py +25,Gantt chart of all tasks.,Gantogram svih zadataka.
+DocType: Pricing Rule,Margin Type,Margina Vrsta
 DocType: Appraisal,For Employee Name,Za ime zaposlenika
 DocType: Holiday List,Clear Table,Jasno Tablica
 DocType: Features Setup,Brands,Brendovi
@@ -1557,20 +1598,25 @@
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +95,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Ostavite se ne može primijeniti / otkazan prije {0}, kao dopust ravnoteža je već ručne proslijeđena u buduće dodjele dopusta rekord {1}"
 DocType: Activity Cost,Costing Rate,Obračun troškova stopa
 ,Customer Addresses And Contacts,Kupčeve adrese i kontakti
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +259,Row #{0}: Asset is mandatory against a Fixed Asset Item,Red # {0}: Imovina je obavezno protiv dugotrajne imovine točki
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +87,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Molimo postavljanje broje serija za sudjelovanje putem Podešavanje&gt; numeriranja Serija
 DocType: Employee,Resignation Letter Date,Ostavka Pismo Datum
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +37,Pricing Rules are further filtered based on quantity.,Pravilnik o određivanju cijena dodatno se filtrira na temelju količine.
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Ponovite kupaca prihoda
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +49,{0} ({1}) must have role 'Expense Approver',"{0} ({1}) mora imati ulogu ""Odobritelj rashoda '"
 apps/erpnext/erpnext/public/js/setup_wizard.js +272,Pair,Par
+DocType: Asset,Depreciation Schedule,Amortizacija Raspored
 DocType: Bank Reconciliation Detail,Against Account,Protiv računa
 DocType: Maintenance Schedule Detail,Actual Date,Stvarni datum
 DocType: Item,Has Batch No,Je Hrpa Ne
 DocType: Delivery Note,Excise Page Number,Trošarina Broj stranice
+DocType: Asset,Purchase Date,Datum kupnje
 DocType: Employee,Personal Details,Osobni podaci
+apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +170,Please set 'Asset Depreciation Cost Center' in Company {0},Molimo postavite &quot;imovinom Centar Amortizacija troškova &#39;u Društvu {0}
 ,Maintenance Schedules,Održavanja rasporeda
 ,Quotation Trends,Trend ponuda
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +138,Item Group not mentioned in item master for item {0},Stavka proizvoda se ne spominje u master artiklu za artikal {0}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +308,Debit To account must be a Receivable account,Zaduženja računa mora biti Potraživanja račun
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +309,Debit To account must be a Receivable account,Zaduženja računa mora biti Potraživanja račun
 DocType: Shipping Rule Condition,Shipping Amount,Dostava Iznos
 ,Pending Amount,Iznos na čekanju
 DocType: Purchase Invoice Item,Conversion Factor,Konverzijski faktor
@@ -1584,23 +1630,22 @@
 DocType: Bank Reconciliation,Include Reconciled Entries,Uključi pomirio objave
 DocType: Leave Control Panel,Leave blank if considered for all employee types,Ostavite prazno ako se odnosi na sve tipove zaposlenika
 DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuirati optužbi na temelju
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +318,Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Račun {0} mora biti tipa 'Nepokretne imovine' kao što je proizvod {1} imovina proizvoda
 DocType: HR Settings,HR Settings,HR postavke
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +127,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: Purchase Invoice,Additional Discount Amount,Dodatni popust Iznos
 DocType: Leave Block List Allow,Leave Block List Allow,Odobrenje popisa neodobrenih odsustava
-apps/erpnext/erpnext/setup/doctype/company/company.py +234,Abbr can not be blank or space,Abbr ne može biti prazno ili prostora
+apps/erpnext/erpnext/setup/doctype/company/company.py +237,Abbr can not be blank or space,Abbr ne može biti prazno ili prostora
 apps/erpnext/erpnext/accounts/doctype/account/account.js +54,Group to Non-Group,Grupa ne-Group
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,sportovi
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +61,Total Actual,Ukupno Stvarni
 apps/erpnext/erpnext/public/js/setup_wizard.js +272,Unit,jedinica
-apps/erpnext/erpnext/stock/get_item_details.py +124,Please specify Company,Navedite tvrtke
+apps/erpnext/erpnext/stock/get_item_details.py +123,Please specify Company,Navedite tvrtke
 ,Customer Acquisition and Loyalty,Stjecanje kupaca i lojalnost
 DocType: Purchase Receipt,Warehouse where you are maintaining stock of rejected items,Skladište na kojem držite zalihe odbijenih proizvoda
 apps/erpnext/erpnext/public/js/setup_wizard.js +42,Your financial year ends on,Vaša financijska godina završava
 DocType: POS Profile,Price List,Cjenik
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +20,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je sada zadana fiskalna godina. Osvježi preglednik kako bi se promjene aktualizirale.
-apps/erpnext/erpnext/projects/doctype/project/project.js +47,Expense Claims,Rashodi Potraživanja
+apps/erpnext/erpnext/projects/doctype/project/project.js +58,Expense Claims,Rashodi Potraživanja
 DocType: Issue,Support,Podrška
 ,BOM Search,BOM Pretraživanje
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +176,Closing (Opening + Totals),Zatvaranje (Otvaranje + iznosi)
@@ -1609,29 +1654,30 @@
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +49,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Stock ravnoteža u batch {0} postat negativna {1} za točku {2} na skladištu {3}
 apps/erpnext/erpnext/config/setup.py +83,"Show / Hide features like Serial Nos, POS etc.","Prikaži / sakrij značajke kao što su serijski broj, prodajno mjesto i sl."
 apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Sljedeći materijal Zahtjevi su automatski podigli na temelju stavke razini ponovno narudžbi
-apps/erpnext/erpnext/controllers/accounts_controller.py +249,Account {0} is invalid. Account Currency must be {1},Račun {0} je nevažeća. Valuta računa mora biti {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +262,Account {0} is invalid. Account Currency must be {1},Račun {0} je nevažeća. Valuta računa mora biti {1}
 apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.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/bank_reconciliation/bank_reconciliation.py +56,Clearance date cannot be before check date in row {0},Datum rasprodaja ne može biti prije datuma check u redu {0}
 DocType: Salary Slip,Deduction,Odbitak
-apps/erpnext/erpnext/stock/get_item_details.py +262,Item Price added for {0} in Price List {1},Cijena dodana za {0} u cjeniku {1}
+apps/erpnext/erpnext/stock/get_item_details.py +261,Item Price added for {0} in Price List {1},Cijena dodana za {0} u cjeniku {1}
 DocType: Address Template,Address Template,Predložak adrese
 apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +128,Please enter Employee Id of this sales person,Unesite ID zaposlenika ove prodaje osobi
 DocType: Territory,Classification of Customers by region,Klasifikacija korisnika po regiji
 DocType: Project,% Tasks Completed,% Odrađeni zadaci
 DocType: Project,Gross Margin,Bruto marža
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +137,Please enter Production Item first,Unesite Proizvodnja predmeta prvi
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +138,Please enter Production Item first,Unesite Proizvodnja predmeta prvi
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +53,Calculated Bank Statement balance,Izračunato banka Izjava stanje
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,onemogućen korisnika
 apps/erpnext/erpnext/crm/doctype/lead/lead.js +32,Quotation,Ponuda
 DocType: Salary Slip,Total Deduction,Ukupno Odbitak
 DocType: Quotation,Maintenance User,Korisnik održavanja
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +142,Cost Updated,Trošak Ažurirano
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +151,Cost Updated,Trošak Ažurirano
 DocType: Employee,Date of Birth,Datum rođenja
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +85,Item {0} has already been returned,Proizvod {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 poslovnu godinu. Svi računovodstvene stavke i druge glavne transakcije su praćene od **Fiskalne godine**.
 DocType: Opportunity,Customer / Lead Address,Kupac / Olovo Adresa
-apps/erpnext/erpnext/stock/doctype/item/item.py +151,Warning: Invalid SSL certificate on attachment {0},Upozorenje: Invalid SSL potvrda o vezanosti {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +156,Warning: Invalid SSL certificate on attachment {0},Upozorenje: Invalid SSL potvrda o vezanosti {0}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +28,Please setup Employee Naming System in Human Resource &gt; HR Settings,Molimo postavljanje zaposlenika sustav imenovanja u ljudskim resursima&gt; HR Postavke
 DocType: Production Order Operation,Actual Operation Time,Stvarni Operacija vrijeme
 DocType: Authorization Rule,Applicable To (User),Odnosi se na (Upute)
 DocType: Purchase Taxes and Charges,Deduct,Odbiti
@@ -1643,8 +1689,8 @@
 ,SO Qty,SO Kol
 apps/erpnext/erpnext/accounts/doctype/account/account.py +179,"Stock entries exist against warehouse {0}, hence you cannot re-assign or modify Warehouse","Stock unosa postoje protiv skladište {0}, stoga ne možete ponovno dodijeliti ili mijenjati skladište"
 DocType: Appraisal,Calculate Total Score,Izračunajte ukupni rezultat
-DocType: Supplier Quotation,Manufacturing Manager,Upravitelj proizvodnje
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +178,Serial No {0} is under warranty upto {1},Serijski Ne {0} je pod jamstvom upto {1}
+DocType: Request for Quotation,Manufacturing Manager,Upravitelj proizvodnje
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +182,Serial No {0} is under warranty upto {1},Serijski Ne {0} je pod jamstvom upto {1}
 apps/erpnext/erpnext/config/stock.py +154,Split Delivery Note into packages.,Split otpremnici u paketima.
 apps/erpnext/erpnext/hooks.py +71,Shipments,Pošiljke
 DocType: Purchase Order Item,To be delivered to customer,Da biste se dostaviti kupcu
@@ -1652,12 +1698,12 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +223,Serial No {0} does not belong to any Warehouse,Serijski broj {0} ne pripada bilo Skladište
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +157,Row # ,Red #
 DocType: Purchase Invoice,In Words (Company Currency),Riječima (valuta tvrtke)
-DocType: Pricing Rule,Supplier,Dobavljač
+DocType: Asset,Supplier,Dobavljač
 DocType: C-Form,Quarter,Četvrtina
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +105,Miscellaneous Expenses,Razni troškovi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +108,Miscellaneous Expenses,Razni troškovi
 DocType: Global Defaults,Default Company,Zadana tvrtka
 apps/erpnext/erpnext/controllers/stock_controller.py +167,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Rashodi ili razlika račun je obvezna za točke {0} jer utječe na ukupnu vrijednost dionica
-apps/erpnext/erpnext/controllers/accounts_controller.py +350,"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","Ne možete prekoračiti za proizvod {0} u redku {1} više od {2}. Kako bi omogućili prekoračenje, molimo promjenite u postavkama skladišta"
+apps/erpnext/erpnext/controllers/accounts_controller.py +363,"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","Ne možete prekoračiti za proizvod {0} u redku {1} više od {2}. Kako bi omogućili prekoračenje, molimo promjenite u postavkama skladišta"
 DocType: Employee,Bank Name,Naziv banke
 apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +27,-Above,-Iznad
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +139,User {0} is disabled,Korisnik {0} je onemogućen
@@ -1666,7 +1712,7 @@
 apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +36,Select Company...,Odaberite tvrtku ...
 DocType: Leave Control Panel,Leave blank if considered for all departments,Ostavite prazno ako se odnosi na sve odjele
 apps/erpnext/erpnext/config/hr.py +175,"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 +361,{0} is mandatory for Item {1},{0} je obavezno za točku {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +354,{0} is mandatory for Item {1},{0} je obavezno za točku {1}
 DocType: Currency Exchange,From Currency,Od novca
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +154,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Odaberite Dodijeljeni iznos, Vrsta računa i broj računa u atleast jednom redu"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +94,Sales Order required for Item {0},Prodajnog naloga potrebna za točke {0}
@@ -1676,11 +1722,11 @@
 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, prodao i zadržao na lageru."
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +94,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/controllers/accounts_controller.py +478,"Row #{0}: Qty must be 1, as item is linked to an asset","Red # {0}: Količina mora biti jedan, jer je predmet vezan za imovinu"
 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. Uklonite stavku &#39;{0}&#39; i spremanje
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Bankarstvo
 apps/erpnext/erpnext/support/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/accounts/page/accounts_browser/accounts_browser.js +296,New Cost Center,Novi trošak
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +36,"Go to the appropriate group (usually Source of Funds &gt; Current Liabilities &gt; Taxes and Duties and create a new Account (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.",Idi u odgovarajuću grupu (obično izvor sredstava&gt; kratkoročne obveze&gt; poreza i pristojbi te stvoriti novi korisnički račun (klikom na Dodaj Child) tipa &quot;porez&quot; i ne spominju stope poreza.
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +299,New Cost Center,Novi trošak
 DocType: Bin,Ordered Quantity,Naručena količina
 apps/erpnext/erpnext/public/js/setup_wizard.js +22,"e.g. ""Build tools for builders""","na primjer ""Alati za graditelje"""
 DocType: Quality Inspection,In Process,U procesu
@@ -1693,10 +1739,11 @@
 DocType: Activity Type,Default Billing Rate,Zadana naplate stopa
 DocType: Time Log Batch,Total Billing Amount,Ukupno naplate Iznos
 apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +47,Receivable Account,Potraživanja račun
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +273,Row #{0}: Asset {1} is already {2},Red # {0}: Imovina {1} Već {2}
 DocType: Quotation Item,Stock Balance,Skladišna bilanca
 apps/erpnext/erpnext/config/selling.py +306,Sales Order to Payment,Prodajnog naloga za plaćanje
 DocType: Expense Claim Detail,Expense Claim Detail,Rashodi Zahtjev Detalj
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +281,Time Logs created:,Vrijeme Evidencije stvorio:
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +283,Time Logs created:,Vrijeme Evidencije stvorio:
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +796,Please select correct account,Molimo odaberite ispravnu račun
 DocType: Item,Weight UOM,Težina UOM
 DocType: Employee,Blood Group,Krvna grupa
@@ -1714,13 +1761,13 @@
 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 stvorili standardni predložak u prodaji poreze i troškove predložak, odaberite jednu i kliknite na gumb ispod."
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +29,Please specify a country for this Shipping Rule or check Worldwide Shipping,Navedite zemlju za ovaj Dostava pravilom ili provjeriti Dostava u svijetu
 DocType: Stock Entry,Total Incoming Value,Ukupno Dolazni vrijednost
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +302,Debit To is required,Zaduženja je potrebno
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +303,Debit To is required,Zaduženja je potrebno
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Kupovni cjenik
 DocType: Offer Letter Term,Offer Term,Ponuda Pojam
 DocType: Quality Inspection,Quality Manager,Upravitelj kvalitete
 DocType: Job Applicant,Job Opening,Posao Otvaranje
 DocType: Payment Reconciliation,Payment Reconciliation,Pomirenje plaćanja
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +141,Please select Incharge Person's name,Odaberite incharge ime osobe
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +145,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/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.
@@ -1728,22 +1775,22 @@
 DocType: Time Log,To Time,Za vrijeme
 DocType: Authorization Rule,Approving Role (above authorized value),Odobravanje ulogu (iznad ovlaštenog vrijednosti)
 apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +25,"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Da biste dodali djece čvorova , istražiti stablo i kliknite na čvoru pod kojima želite dodati više čvorova ."
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +103,Credit To account must be a Payable account,Kredit računa mora biti naplativo račun
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +234,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 +104,Credit To account must be a Payable account,Kredit računa mora biti naplativo račun
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +243,BOM recursion: {0} cannot be parent or child of {2},BOM rekurzija : {0} ne može biti roditelj ili dijete od {2}
 DocType: Production Order Operation,Completed Qty,Završen Kol
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +121,"For {0}, only debit accounts can be linked against another credit entry","Za {0}, samo debitne računi se mogu povezati protiv druge kreditne stupanja"
-apps/erpnext/erpnext/stock/get_item_details.py +273,Price List {0} is disabled,Cjenik {0} je ugašen
+apps/erpnext/erpnext/stock/get_item_details.py +272,Price List {0} is disabled,Cjenik {0} je ugašen
 DocType: Manufacturing Settings,Allow Overtime,Dopusti Prekovremeni
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +197,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} serijski brojevi potrebni za Artikl {1}. Ti su dali {2}.
 DocType: Stock Reconciliation Item,Current Valuation Rate,Trenutno Vrednovanje Ocijenite
 DocType: Item,Customer Item Codes,Kupac Stavka Kodovi
 DocType: Opportunity,Lost Reason,Razlog gubitka
-apps/erpnext/erpnext/config/accounts.py +123,Create Payment Entries against Orders or Invoices.,Stvaranje unosa plaćanja protiv narudžbe ili fakture.
+apps/erpnext/erpnext/config/accounts.py +131,Create Payment Entries against Orders or Invoices.,Stvaranje unosa plaćanja protiv narudžbe ili fakture.
 apps/erpnext/erpnext/public/js/templates/address_list.html +1,New Address,Nova adresa
 DocType: Quality Inspection,Sample Size,Veličina uzorka
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +488,All items have already been invoiced,Svi proizvodi su već fakturirani
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +47,Please specify a valid 'From Case No.',Navedite važeću &#39;iz Predmet br&#39;
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +300,Further cost centers can be made under Groups but entries can be made against non-Groups,"Daljnje troška mogu biti u skupinama, ali unose se može podnijeti protiv nesrpskog Groups"
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +303,Further cost centers can be made under Groups but entries can be made against non-Groups,"Daljnje troška mogu biti u skupinama, ali unose se može podnijeti protiv nesrpskog Groups"
 DocType: Project,External,Vanjski
 DocType: Features Setup,Item Serial Nos,Serijski br proizvoda
 apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Korisnici i dozvole
@@ -1752,10 +1799,11 @@
 apps/erpnext/erpnext/hr/report/monthly_salary_register/monthly_salary_register.py +66,No salary slip found for month:,Ne plaća slip naći za mjesec dana:
 DocType: Bin,Actual Quantity,Stvarna količina
 DocType: Shipping Rule,example: Next Day Shipping,Primjer: Sljedeći dan Dostava
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +175,Serial No {0} not found,Serijski broj {0} nije pronađen
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +179,Serial No {0} not found,Serijski broj {0} nije pronađen
 apps/erpnext/erpnext/public/js/setup_wizard.js +211,Your Customers,Vaši klijenti
+apps/erpnext/erpnext/projects/doctype/project/project.py +131,You have been invited to collaborate on the project: {0},Pozvani ste da surađuju na projektu: {0}
 DocType: Leave Block List Date,Block Date,Datum bloka
-apps/erpnext/erpnext/templates/generators/job_opening.html +17,Apply Now,Primijeni sada
+apps/erpnext/erpnext/templates/generators/job_opening.html +18,Apply Now,Primijeni sada
 DocType: Sales Order,Not Delivered,Ne isporučeno
 ,Bank Clearance Summary,Razmak banka Sažetak
 apps/erpnext/erpnext/config/setup.py +105,"Create and manage daily, weekly and monthly email digests.","Stvaranje i upravljanje automatskih mailova na dnevnoj, tjednoj i mjesečnoj bazi."
@@ -1779,7 +1827,7 @@
 DocType: Employee,Employment Details,Zapošljavanje Detalji
 DocType: Employee,New Workplace,Novo radno mjesto
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Postavi kao zatvoreno
-apps/erpnext/erpnext/stock/get_item_details.py +114,No Item with Barcode {0},Nema proizvoda sa barkodom {0}
+apps/erpnext/erpnext/stock/get_item_details.py +113,No Item with Barcode {0},Nema proizvoda sa barkodom {0}
 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: Features Setup,If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,Ako imate prodajnog tima i prodaja partnerima (partneri) mogu biti označene i održavati svoj doprinos u prodajne aktivnosti
 DocType: Item,Show a slideshow at the top of the page,Prikaži slideshow na vrhu stranice
@@ -1797,10 +1845,10 @@
 DocType: Rename Tool,Rename Tool,Preimenovanje
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +15,Update Cost,Update cost
 DocType: Item Reorder,Item Reorder,Ponovna narudžba proizvoda
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +608,Transfer Material,Prijenos materijala
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +611,Transfer Material,Prijenos materijala
 apps/erpnext/erpnext/controllers/selling_controller.py +236,Item {0} must be a Sales Item in {1},Stavka {0} mora biti Prodaja predmeta u {1}
 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 ."
-apps/erpnext/erpnext/public/js/controllers/transaction.js +839,Please set recurring after saving,Molimo postavite ponavljajući nakon spremanja
+apps/erpnext/erpnext/public/js/controllers/transaction.js +850,Please set recurring after saving,Molimo postavite ponavljajući nakon spremanja
 DocType: Purchase Invoice,Price List Currency,Valuta cjenika
 DocType: Naming Series,User must always select,Korisničko uvijek mora odabrati
 DocType: Stock Settings,Allow Negative Stock,Dopustite negativnu zalihu
@@ -1814,12 +1862,13 @@
 DocType: Quality Inspection,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/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +158,Source of Funds (Liabilities),Izvor sredstava ( pasiva)
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +161,Source of Funds (Liabilities),Izvor sredstava ( pasiva)
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +347,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Količina u redku {0} ({1}) mora biti ista kao proizvedena količina {2}
 DocType: Appraisal,Employee,Zaposlenik
 apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +10,Import Email From,Uvoz e od
 apps/erpnext/erpnext/utilities/doctype/contact/contact.js +70,Invite as User,Pozovi kao korisnik
 DocType: Features Setup,After Sale Installations,Nakon prodaje postrojenja
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +111,Please set {0} in Company {1},Molimo postavite {0} u Društvu {1}
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,{0} {1} is fully billed,{0} {1} je naplaćen u cijelosti
 DocType: Workstation Working Hour,End Time,Kraj vremena
 apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standardni uvjeti ugovora za prodaju ili kupnju.
@@ -1828,9 +1877,9 @@
 apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Potrebna On
 DocType: Sales Invoice,Mass Mailing,Grupno slanje mailova
 DocType: Rename Tool,File to Rename,Datoteka za Preimenovanje
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +201,Please select BOM for Item in Row {0},Odaberite BOM za točku u nizu {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +181,Purchse Order number required for Item {0},Broj kupovne narudžbe potrebno za proizvod {0}
-apps/erpnext/erpnext/controllers/buying_controller.py +236,Specified BOM {0} does not exist for Item {1},Određena BOM {0} ne postoji za točku {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +204,Please select BOM for Item in Row {0},Odaberite BOM za točku u nizu {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +183,Purchse Order number required for Item {0},Broj kupovne narudžbe potrebno za proizvod {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +237,Specified BOM {0} does not exist for Item {1},Određena BOM {0} ne postoji za točku {1}
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +196,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Stavka održavanja {0} mora biti otkazana prije poništenja ove narudžbe kupca
 DocType: Notification Control,Expense Claim Approved,Rashodi Zahtjev odobren
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +113,Pharmaceutical,Farmaceutski
@@ -1842,30 +1891,30 @@
 DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Detalji rasporeda održavanja
 DocType: Quality Inspection Reading,Reading 9,Čitanje 9
 DocType: Supplier,Is Frozen,Je Frozen
-DocType: Buying Settings,Buying Settings,Kupnja postavke
+DocType: Buying Settings,Buying Settings,Ppostavke nabave
 DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM broj za Gotovi Dobar točki
 DocType: Upload Attendance,Attendance To Date,Gledanost do danas
 DocType: Warranty Claim,Raised By,Povišena Do
 DocType: Payment Gateway Account,Payment Account,Račun za plaćanje
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +737,Please specify Company to proceed,Navedite Tvrtka postupiti
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +780,Please specify Company to proceed,Navedite Tvrtka postupiti
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +20,Net Change in Accounts Receivable,Neto promjena u potraživanja
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +46,Compensatory Off,kompenzacijski Off
 DocType: Quality Inspection Reading,Accepted,Prihvaćeno
 apps/erpnext/erpnext/setup/doctype/company/company.js +46,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 provjerite da li stvarno želite izbrisati sve transakcije za ovu tvrtku. Vaši matični podaci će ostati kao što je to. Ova radnja se ne može poništiti.
 apps/erpnext/erpnext/utilities/transaction_base.py +93,Invalid reference {0} {1},Pogrešna referentni {0} {1}
 DocType: Payment Tool,Total Payment Amount,Ukupna plaćanja Iznos
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +145,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) ne može biti veći od planirane količine ({2}) u proizvodnom nalogu {3}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +147,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) ne može biti veći od planirane količine ({2}) u proizvodnom nalogu {3}
 DocType: Shipping Rule,Shipping Rule Label,Dostava Pravilo Label
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +210,Raw Materials cannot be blank.,Sirovine ne može biti prazno.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +423,"Could not update stock, invoice contains drop shipping item.","Ne može se ažurirati zaliha, fakture sadrži drop shipping stavke."
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +219,Raw Materials cannot be blank.,Sirovine ne može biti prazno.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +416,"Could not update stock, invoice contains drop shipping item.","Ne može se ažurirati zaliha, fakture sadrži drop shipping stavke."
 DocType: Newsletter,Test,Test
-apps/erpnext/erpnext/stock/doctype/item/item.py +402,"As there are existing stock transactions for this item, \
+apps/erpnext/erpnext/stock/doctype/item/item.py +407,"As there are existing stock transactions for this item, \
 							you can not change the values of 'Has Serial No', 'Has Batch No', 'Is Stock Item' and 'Valuation Method'","Kao što već postoje dionice transakcija za tu stavku, \ ne možete mijenjati vrijednosti &#39;Je rednim&#39;, &#39;Je batch Ne&#39;, &#39;Je kataloški Stavka &quot;i&quot; Vrednovanje metoda&#39;"
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +449,Quick Journal Entry,Brzo Temeljnica
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +100,You can not change rate if BOM mentioned agianst any item,Ne možete promijeniti cijenu ako je sastavnica spomenuta u bilo kojem proizvodu
 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 +206,Please enter Planned Qty for Item {0} at row {1},Unesite Planirano Qty za točku {0} na redu {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +209,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 +214,{0} {1} is not submitted,{0} {1} nije podnesen
 apps/erpnext/erpnext/config/stock.py +27,Requests for items.,Zahtjevi za stavke.
 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.
@@ -1874,7 +1923,7 @@
 apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +121,Please save the document before generating maintenance schedule,Molimo spremite dokument prije stvaranja raspored za održavanje
 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 +366,The following Production Orders were created:,Sljedeći Radni nalozi stvorili su:
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +388,The following Production Orders were created:,Sljedeći Radni nalozi stvorili su:
 apps/erpnext/erpnext/config/crm.py +116,Newsletter Mailing List,Bilten Mailing lista
 DocType: Delivery Note,Transporter Name,Transporter Ime
 DocType: Authorization Rule,Authorized Value,Ovlašteni vrijednost
@@ -1892,13 +1941,13 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +220,{0} {1} is closed,{0} {1} je zatvorena
 DocType: Email Digest,How frequently?,Kako često?
 DocType: Purchase Receipt,Get Current Stock,Kreiraj trenutne zalihe
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +32,"Go to the appropriate group (usually Application of Funds &gt; Current Assets &gt; Bank Accounts and create a new Account (by clicking on Add Child) of type ""Bank""",Idi u odgovarajuću grupu (obično Application fondova&gt; kratkotrajne imovine&gt; bankovnih računa i stvorili novi račun (klikom na Dodaj Child) tipa &quot;Banka&quot;
 apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Drvo Bill materijala
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +151,Mark Present,Mark Sadašnje
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +185,Maintenance start date can not be before delivery date for Serial No {0},Početni datum održavanja ne može biti stariji od datuma isporuke s rednim brojem {0}
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +189,Maintenance start date can not be before delivery date for Serial No {0},Početni datum održavanja ne može biti stariji od datuma isporuke s rednim brojem {0}
 DocType: Production Order,Actual End Date,Stvarni datum završetka
 DocType: Authorization Rule,Applicable To (Role),Odnosi se na (uloga)
 DocType: Stock Entry,Purpose,Svrha
+DocType: Company,Fixed Asset Depreciation Settings,Postavke Amortizacija osnovnog sredstva
 DocType: Item,Will also apply for variants unless overrridden,Također će zatražiti varijante osim overrridden
 DocType: Purchase Invoice,Advances,Predujmovi
 DocType: Production Order,Manufacture against Material Request,Proizvodnja od materijala dogovoru
@@ -1907,6 +1956,7 @@
 DocType: SMS Log,No of Requested SMS,Nema traženih SMS-a
 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 +593,Please supply the specified items at the best possible rates,Molimo dostaviti navedene stavke po najboljim mogućim cijenama
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Contract End Date must be greater than Date of Joining,Ugovor Datum završetka mora biti veći od dana ulaska u
 DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Treća strana distributer / trgovac / trgovački zastupnik / affiliate / prodavača koji prodaje tvrtki koje proizvode za proviziju.
 DocType: Customer Group,Has Child Node,Je li čvor dijete
@@ -1957,12 +2007,14 @@
  9. Razmislite poreza ili naplatiti za: U ovom dijelu možete odrediti ako porezni / zadužen samo za vrednovanje (nije dio ukupno), ili samo za ukupno (ne dodaju vrijednost predmeta), ili za oboje.
  10. Dodavanje ili oduzimamo: Bilo da želite dodati ili oduzeti porez."
 DocType: Purchase Receipt Item,Recd Quantity,RecD Količina
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +104,Cannot produce more Item {0} than Sales Order quantity {1},Ne može proizvesti više predmeta {0} od prodajnog naloga količina {1}
+DocType: Asset Category Account,Asset Category Account,Imovina Kategorija račun
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +106,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 +497,Stock Entry {0} is not submitted,Međuskladišnica {0} nije potvrđena
 DocType: Payment Reconciliation,Bank / Cash Account,Banka / Cash račun
 DocType: Tax Rule,Billing City,Naplata Grad
 DocType: Global Defaults,Hide Currency Symbol,Sakrij simbol valute
-apps/erpnext/erpnext/config/accounts.py +262,"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice"
+apps/erpnext/erpnext/config/accounts.py +270,"e.g. Bank, Cash, Credit Card","npr. banka, gotovina, kreditne kartice"
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +32,"Go to the appropriate group (usually Application of Funds &gt; Current Assets &gt; Bank Accounts and create a new Account (by clicking on Add Child) of type ""Bank""",Idi u odgovarajuću grupu (obično Application fondova&gt; kratkotrajne imovine&gt; bankovnih računa i stvorili novi račun (klikom na Dodaj Child) tipa &quot;Banka&quot;
 DocType: Journal Entry,Credit Note,Kreditne Napomena
 apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +218,Completed Qty cannot be more than {0} for operation {1},Završen Kol ne može biti više od {0} za rad {1}
 DocType: Features Setup,Quality,Kvaliteta
@@ -1986,9 +2038,9 @@
 apps/erpnext/erpnext/utilities/doctype/address/address.py +125,My Addresses,Moje Adrese
 DocType: Stock Ledger Entry,Outgoing Rate,Odlazni Ocijenite
 apps/erpnext/erpnext/config/hr.py +180,Organization branch master.,Organizacija grana majstor .
-apps/erpnext/erpnext/controllers/accounts_controller.py +250, or ,ili
+apps/erpnext/erpnext/controllers/accounts_controller.py +263, or ,ili
 DocType: Sales Order,Billing Status,Status naplate
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Utility Expenses,komunalna Troškovi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Utility Expenses,komunalna Troškovi
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,90-Above,90-Iznad
 DocType: Buying Settings,Default Buying Price List,Zadani kupovni cjenik
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +83,No employee for the above selected criteria OR salary slip already created,Niti jedan zaposlenik za prethodno izabrane kriterije ili plaća klizanja već stvorili
@@ -2015,7 +2067,7 @@
 DocType: Product Bundle,Parent Item,Nadređeni proizvod
 DocType: Account,Account Type,Vrsta računa
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +113,Leave Type {0} cannot be carry-forwarded,Ostavite Tip {0} ne može nositi-proslijeđen
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Raspored održavanja nije generiran za sve proizvode. Molimo kliknite na 'Generiraj raspored'
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +204,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Raspored održavanja nije generiran za sve proizvode. Molimo kliknite na 'Generiraj raspored'
 ,To Produce,proizvoditi
 apps/erpnext/erpnext/config/hr.py +93,Payroll,Platni spisak
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +119,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Za red {0} {1}. Da su {2} u stopu točke, redovi {3} također moraju biti uključeni"
@@ -2025,8 +2077,9 @@
 DocType: Landed Cost Voucher,Purchase Receipt Items,Primka proizvoda
 apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Prilagodba Obrasci
 DocType: Account,Income Account,Račun prihoda
+apps/erpnext/erpnext/utilities/doctype/address/address.py +151,No default Address Template found. Please create a new one from Setup &gt; Printing and Branding &gt; Address Template.,Ne zadana adresa predloška pronađen. Molimo stvoriti novi iz Setup&gt; Tisak i Branding&gt; Address predložak.
 DocType: Payment Request,Amount in customer's currency,Iznos u valuti kupca
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +654,Delivery,Isporuka
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +697,Delivery,Isporuka
 DocType: Stock Reconciliation Item,Current Qty,Trenutno Kom
 DocType: BOM Item,"See ""Rate Of Materials Based On"" in Costing Section",Pogledajte &quot;stopa materijali na temelju troškova&quot; u odjeljak
 DocType: Appraisal Goal,Key Responsibility Area,Zona ključnih odgovornosti
@@ -2048,21 +2101,22 @@
 apps/erpnext/erpnext/config/selling.py +168,Track Leads by Industry Type.,Praćenje potencijalnih kupaca prema vrsti industrije.
 DocType: Item Supplier,Item Supplier,Dobavljač proizvoda
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +326,Please enter Item Code to get batch no,Unesite kod Predmeta da se hrpa nema
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +665,Please select a value for {0} quotation_to {1},Molimo odabir vrijednosti za {0} quotation_to {1}
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +708,Please select a value for {0} quotation_to {1},Molimo odabir vrijednosti za {0} quotation_to {1}
 apps/erpnext/erpnext/config/selling.py +47,All Addresses.,Sve adrese.
 DocType: Company,Stock Settings,Postavke skladišta
-apps/erpnext/erpnext/accounts/doctype/account/account.py +218,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spajanje je moguće samo ako sljedeća svojstva su isti u obje evidencije. Je Grupa, korijen Vrsta, Društvo"
+apps/erpnext/erpnext/accounts/doctype/account/account.py +215,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spajanje je moguće samo ako sljedeća svojstva su isti u obje evidencije. Je Grupa, korijen Vrsta, Društvo"
 apps/erpnext/erpnext/config/crm.py +92,Manage Customer Group Tree.,Uredi hijerarhiju grupe kupaca.
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +298,New Cost Center Name,Novi naziv troškovnog centra
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +301,New Cost Center Name,Novi naziv troškovnog centra
 DocType: Leave Control Panel,Leave Control Panel,Upravljačka ploča odsustava
 DocType: Appraisal,HR User,HR Korisnik
 DocType: Purchase Invoice,Taxes and Charges Deducted,Porezi i naknade oduzeti
-apps/erpnext/erpnext/config/support.py +7,Issues,Pitanja
+apps/erpnext/erpnext/hooks.py +90,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: Delivery Note,Required only for sample item.,Potrebna je samo za primjer stavke.
 DocType: Stock Ledger Entry,Actual Qty After Transaction,Stvarna količina nakon transakcije
 ,Pending SO Items For Purchase Request,Otvorene stavke narudžbe za zahtjev za kupnju
+apps/erpnext/erpnext/accounts/party.py +322,{0} {1} is disabled,{0} {1} je onemogućen
 DocType: Supplier,Billing Currency,Naplata valuta
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +148,Extra Large,Extra large
 ,Profit and Loss Statement,Račun dobiti i gubitka
@@ -2076,10 +2130,10 @@
 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 +147,Large,Veliki
 DocType: C-Form Invoice Detail,Territory,Teritorij
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +139,Please mention no of visits required,Molimo spomenuti nema posjeta potrebnih
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +143,Please mention no of visits required,Molimo spomenuti nema posjeta potrebnih
 DocType: Stock Settings,Default Valuation Method,Zadana metoda vrednovanja
 DocType: Production Order Operation,Planned Start Time,Planirani početak vremena
-apps/erpnext/erpnext/config/accounts.py +214,Close Balance Sheet and book Profit or Loss.,Zatvori bilanca i knjiga dobit ili gubitak .
+apps/erpnext/erpnext/config/accounts.py +222,Close Balance Sheet and book Profit or Loss.,Zatvori bilanca i knjiga dobit ili gubitak .
 DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Navedite Tečaj pretvoriti jedne valute u drugu
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +142,Quotation {0} is cancelled,Ponuda {0} je otkazana
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +26,Total Outstanding Amount,Ukupni iznos
@@ -2147,13 +2201,14 @@
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +109,Atleast one item should be entered with negative quantity in return document,Atleast jedan predmet treba upisati s negativnim količinama u povratnom dokumentu
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +67,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operacija {0} više nego bilo raspoloživih radnih sati u radnom {1}, razbiti rad u više operacija"
 ,Requested,Tražena
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +67,No Remarks,Nema primjedbi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +68,No Remarks,Nema primjedbi
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +13,Overdue,Prezadužen
 DocType: Account,Stock Received But Not Billed,Stock primljeni Ali ne Naplaćeno
 apps/erpnext/erpnext/accounts/doctype/account/account.py +83,Root Account must be a group,Korijen računa mora biti grupa
 DocType: Salary Slip,Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Bruto plaće + + zaostatak Iznos Iznos Encashment - Ukupno Odbitak
 DocType: Monthly Distribution,Distribution Name,Naziv distribucije
 DocType: Features Setup,Sales and Purchase,Prodaje i kupnje
+apps/erpnext/erpnext/stock/doctype/item/item.py +574,Fixed Asset Item must be a non-stock item,Fiksni Asset Stavka mora biti ne-stock točka a
 DocType: Supplier Quotation Item,Material Request No,Zahtjev za robom br.
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +211,Quality Inspection required for Item {0},Inspekcija kvalitete potrebna za proizvod {0}
 DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Stopa po kojoj se valuta klijenta se pretvaraju u tvrtke bazne valute
@@ -2174,7 +2229,7 @@
 DocType: Bank Reconciliation,Get Relevant Entries,Kreiraj relevantne ulaze
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407,Accounting Entry for Stock,Knjiženje na skladištu
 DocType: Sales Invoice,Sales Team1,Prodaja Team1
-apps/erpnext/erpnext/stock/doctype/item/item.py +449,Item {0} does not exist,Proizvod {0} ne postoji
+apps/erpnext/erpnext/stock/doctype/item/item.py +454,Item {0} does not exist,Proizvod {0} ne postoji
 DocType: Sales Invoice,Customer Address,Kupac Adresa
 DocType: Payment Request,Recipient and Message,Primatelj i poruka
 DocType: Purchase Invoice,Apply Additional Discount On,Nanesite dodatni popust na
@@ -2188,7 +2243,7 @@
 DocType: Purchase Invoice,Select Supplier Address,Odaberite Dobavljač adresa
 DocType: Quality Inspection,Quality Inspection,Provjera kvalitete
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +144,Extra Small,Dodatni Mali
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +579,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 +582,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 +190,Account {0} is frozen,Račun {0} je zamrznut
 DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Pravna cjelina / Podružnica s odvojenim kontnim planom pripada Organizaciji.
 DocType: Payment Request,Mute Email,Mute e
@@ -2210,12 +2265,13 @@
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,softver
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +151,Colour,Boja
 DocType: Maintenance Visit,Scheduled,Planiran
+apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Zahtjev 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 stavku u kojoj &quot;Je kataloški Stavka&quot; je &quot;Ne&quot; i &quot;Je Prodaja Stavka&quot; &quot;Da&quot;, a ne postoji drugi bala proizvoda"
-apps/erpnext/erpnext/controllers/accounts_controller.py +405,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupno unaprijed ({0}) protiv Red {1} ne može biti veći od sveukupnog ({2})
+apps/erpnext/erpnext/controllers/accounts_controller.py +418,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Ukupno unaprijed ({0}) protiv Red {1} ne može biti veći od sveukupnog ({2})
 DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Odaberite mjesečna distribucija na nejednako distribuirati ciljeve diljem mjeseci.
 DocType: Purchase Invoice Item,Valuation Rate,Stopa vrednovanja
-apps/erpnext/erpnext/stock/get_item_details.py +294,Price List Currency not selected,Valuta cjenika nije odabrana
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,Stavka Red {0}: Kupnja Potvrda {1} ne postoji u gornjoj tablici 'kupiti primitaka'
+apps/erpnext/erpnext/stock/get_item_details.py +293,Price List Currency not selected,Valuta cjenika nije odabrana
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,Red stavke {0}:Primka {1} ne postoji u gornjem popisu primki
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +158,Employee {0} has already applied for {1} between {2} and {3},Zaposlenik {0} već podnijela zahtjev za {1} od {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 +8,Until,Do
@@ -2223,7 +2279,7 @@
 DocType: Installation Note Item,Against Document No,Protiv dokumentu nema
 apps/erpnext/erpnext/config/selling.py +113,Manage Sales Partners.,Uredi prodajne partnere.
 DocType: Quality Inspection,Inspection Type,Inspekcija Tip
-apps/erpnext/erpnext/controllers/recurring_document.py +165,Please select {0},Odaberite {0}
+apps/erpnext/erpnext/controllers/recurring_document.py +166,Please select {0},Odaberite {0}
 DocType: C-Form,C-Form No,C-obrazac br
 DocType: BOM,Exploded_items,Exploded_items
 DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačeno posjećenost
@@ -2238,11 +2294,12 @@
 DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Za praktičnost kupaca, te kodovi mogu se koristiti u tiskanim formata kao što su fakture i otpremnice"
 DocType: Employee,You can enter any date manually,Možete ručno unijeti bilo koji datum
 DocType: Sales Invoice,Advertisement,Oglas
+DocType: Asset Category Account,Depreciation Expense Account,Amortizacija reprezentaciju
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +165,Probationary Period,Probni
 DocType: Customer Group,Only leaf nodes are allowed in transaction,Samo lisni čvorovi su dozvoljeni u transakciji
 DocType: Expense Claim,Expense Approver,Rashodi Odobritelj
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +109,Row {0}: Advance against Customer must be credit,Red {0}: Advance protiv Kupac mora biti kreditna
-DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Kupnja Prijem artikla Isporuka
+DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Zaprimljena stavka iz primke
 apps/erpnext/erpnext/public/js/pos/pos.js +356,Pay,Platiti
 apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +17,To Datetime,Za datetime
 DocType: SMS Settings,SMS Gateway URL,SMS Gateway URL
@@ -2251,7 +2308,7 @@
 apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +166,Confirmed,Potvrđen
 DocType: Payment Gateway,Gateway,Prolaz
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +131,Please enter relieving date.,Unesite olakšavanja datum .
-apps/erpnext/erpnext/controllers/trends.py +141,Amt,AMT
+apps/erpnext/erpnext/controllers/trends.py +145,Amt,AMT
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +53,Only Leave Applications with status 'Approved' can be submitted,"Samo zahtjev za odsustvom sa statusom ""Odobreno"" se može potvrditi"
 apps/erpnext/erpnext/utilities/doctype/address/address.py +25,Address Title is mandatory.,Naziv adrese je obavezan.
 DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Unesite naziv kampanje, ako je izvor upit je kampanja"
@@ -2265,18 +2322,19 @@
 DocType: Purchase Receipt Item,Accepted Warehouse,Prihvaćeno skladište
 DocType: Bank Reconciliation Detail,Posting Date,Datum objave
 DocType: Item,Valuation Method,Metoda vrednovanja
-apps/erpnext/erpnext/setup/utils.py +91,Unable to find exchange rate for {0} to {1},Nije moguće pronaći tečaj za {0} do {1}
+apps/erpnext/erpnext/setup/utils.py +93,Unable to find exchange rate for {0} to {1},Nije moguće pronaći tečaj za {0} do {1}
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +202,Mark Half Day,Mark Poludnevni
 DocType: Sales Invoice,Sales Team,Prodajni tim
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +88,Duplicate entry,Dupli unos
 DocType: Serial No,Under Warranty,Pod jamstvom
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +410,[Error],[Greška]
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +413,[Error],[Greška]
 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đendan zaposlenika
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,venture Capital
 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)
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serijski Ne {0} ne postoji
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +52,Supplier &gt; Supplier Type,Dobavljač&gt; Vrsta Dobavljač
 DocType: Sales Invoice Item,Customer Warehouse (Optional),Kupac skladišta (po izboru)
 DocType: Pricing Rule,Discount Percentage,Postotak popusta
 DocType: Payment Reconciliation Invoice,Invoice Number,Račun broj
@@ -2287,7 +2345,7 @@
 DocType: Manufacturing Settings,Material Transferred for Manufacture,Materijal prenose Proizvodnja
 DocType: Expense Claim,"A user with ""Expense Approver"" role","Korisnik s ""Rashodi Odobritelj"" ulozi"
 ,Issued Items Against Production Order,Izdana Proizvodi prema proizvodnji Reda
-DocType: Pricing Rule,Purchase Manager,Kupnja Manager
+DocType: Pricing Rule,Purchase Manager,Upravitelj nabave
 DocType: Payment Tool,Payment Tool,Alat za plaćanje
 DocType: Target Detail,Target Detail,Ciljana Detalj
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +20,All Jobs,Svi poslovi
@@ -2302,14 +2360,16 @@
 apps/erpnext/erpnext/accounts/page/pos/pos_page.html +4,Select type of transaction,Odaberite tip transakcije
 DocType: GL Entry,Voucher No,Bon Ne
 DocType: Leave Allocation,Leave Allocation,Raspodjela odsustva
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +471,Material Requests {0} created,Zahtjevi za robom {0} kreirani
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +474,Material Requests {0} created,Zahtjevi za robom {0} kreirani
 apps/erpnext/erpnext/config/selling.py +158,Template of terms or contract.,Predložak izraza ili ugovora.
 DocType: Purchase Invoice,Address and Contact,Kontakt
 DocType: Supplier,Last Day of the Next Month,Posljednji dan sljedećeg mjeseca
 DocType: Employee,Feedback,Povratna veza
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +66,"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 dopust ravnoteža je već ručne proslijeđena u buduće dodjele dopusta rekord {1}"
-apps/erpnext/erpnext/accounts/party.py +280,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Napomena: S obzirom / Referentni datum prelazi dopuštene kupca kreditne dana od {0} dana (s)
+apps/erpnext/erpnext/accounts/party.py +286,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Napomena: S obzirom / Referentni datum prelazi dopuštene kupca kreditne dana od {0} dana (s)
+DocType: Asset Category Account,Accumulated Depreciation Account,Akumulirana amortizacija računa
 DocType: Stock Settings,Freeze Stock Entries,Zamrzavanje Stock Unosi
+DocType: Asset,Expected Value After Useful Life,Očekivana vrijednost nakon korisnog vijeka trajanja
 DocType: Item,Reorder level based on Warehouse,Razina redoslijeda na temelju Skladište
 DocType: Activity Cost,Billing Rate,Ocijenite naplate
 ,Qty to Deliver,Količina za otpremu
@@ -2322,12 +2382,12 @@
 apps/erpnext/erpnext/controllers/stock_controller.py +248,{0} {1} is cancelled or closed,{0} {1} je otkazan ili zatvoren
 DocType: Delivery Note,Track this Delivery Note against any Project,Prati ovu napomenu isporuke protiv bilo Projekta
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28,Net Cash from Investing,Neto novac od investicijskih
-apps/erpnext/erpnext/accounts/doctype/account/account.py +193,Root account can not be deleted,Korijen račun ne može biti izbrisan
 ,Is Primary Address,Je Osnovna adresa
 DocType: Production Order,Work-in-Progress Warehouse,Rad u tijeku Warehouse
+apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +99,Asset {0} must be submitted,Imovina {0} mora biti predana
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +324,Reference #{0} dated {1},Reference # {0} od {1}
 apps/erpnext/erpnext/templates/includes/cart/cart_address.html +16,Manage Addresses,Upravljanje adrese
-DocType: Pricing Rule,Item Code,Šifra proizvoda
+DocType: Asset,Item Code,Šifra proizvoda
 DocType: Production Planning Tool,Create Production Orders,Napravi proizvodni nalog
 DocType: Serial No,Warranty / AMC Details,Jamstveni / AMC Brodu
 DocType: Journal Entry,User Remark,Upute Zabilješka
@@ -2346,8 +2406,10 @@
 DocType: Production Planning Tool,Create Material Requests,Zahtjevnica za nabavu
 DocType: Employee Education,School/University,Škola / Sveučilište
 DocType: Payment Request,Reference Details,Referentni Detalji
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +37,Expected Value After Useful Life must be less than Gross Purchase Amount,Očekivana vrijednost nakon korisnog vijeka trajanja mora biti manja od bruto iznosa kupnje
 DocType: Sales Invoice Item,Available Qty at Warehouse,Dostupna količina na skladištu
 ,Billed Amount,Naplaćeni iznos
+DocType: Asset,Double Declining Balance,Dvaput padu Stanje
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +163,Closed order cannot be cancelled. Unclose to cancel.,Zatvorena redoslijed ne može se otkazati. Otvarati otkazati.
 DocType: Bank Reconciliation,Bank Reconciliation,Banka pomirenje
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +9,Get Updates,Nabavite ažuriranja
@@ -2366,6 +2428,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +242,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Razlika računa mora biti tipa imovine / obveza račun, jer to kataloški Pomirenje je otvaranje Stupanje"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +131,Purchase Order number required for Item {0},Broj narudžbenice kupnje je potreban za artikal {0}
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date','Od datuma' mora biti poslije 'Do datuma'
+DocType: Asset,Fully Depreciated,potpuno amortizirana
 ,Stock Projected Qty,Stanje skladišta
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +137,Customer {0} does not belong to project {1},Korisnik {0} ne pripada projicirati {1}
 DocType: Employee Attendance Tool,Marked Attendance HTML,Označena Gledatelja HTML
@@ -2373,25 +2436,28 @@
 apps/erpnext/erpnext/config/stock.py +108,Serial No and Batch,Serijski broj i serije
 DocType: Warranty Claim,From Company,Iz Društva
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +95,Value or Qty,"Vrijednost, ili Kol"
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +368,Productions Orders cannot be raised for:,Productions narudžbe se ne može podići za:
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +390,Productions Orders cannot be raised for:,Productions narudžbe se ne može podići za:
 apps/erpnext/erpnext/public/js/setup_wizard.js +273,Minute,Minuta
-DocType: Purchase Invoice,Purchase Taxes and Charges,Kupnja Porezi i naknade
+DocType: Purchase Invoice,Purchase Taxes and Charges,Nabavni porezi i terećenja
 ,Qty to Receive,Količina za primanje
 DocType: Leave Block List,Leave Block List Allowed,Odobreni popis neodobrenih odsustava
 DocType: Sales Partner,Retailer,Prodavač na malo
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +100,Credit To account must be a Balance Sheet account,Kredit na računu mora biti bilanca račun
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +101,Credit To account must be a Balance Sheet account,Kredit na računu mora biti bilanca račun
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +128,All Supplier Types,Sve vrste dobavljača
 DocType: Global Defaults,Disable In Words,Onemogućavanje riječima
 apps/erpnext/erpnext/stock/doctype/item/item.py +46,Item Code is mandatory because Item is not automatically numbered,Kod proizvoda je obvezan jer artikli nisu automatski numerirani
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +94,Quotation {0} not of type {1},Ponuda {0} nije tip {1}
 DocType: Maintenance Schedule Item,Maintenance Schedule Item,Stavka rasporeda održavanja
 DocType: Sales Order,%  Delivered,% Isporučeno
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +177,Bank Overdraft Account,Bank Prekoračenje računa
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +180,Bank Overdraft Account,Bank Prekoračenje računa
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +46,Item Code &gt; Item Group &gt; Brand,Stavka Šifra&gt; Stavka Group&gt; Brand
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +18,Browse BOM,Pretraživanje BOM
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +175,Secured Loans,osigurani krediti
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +178,Secured Loans,osigurani krediti
+apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +89,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Molimo postavite Amortizacija se odnose računi u imovini Kategorija {0} ili Društvo {1}
 apps/erpnext/erpnext/setup/setup_wizard/data/sample_home_page.html +3,Awesome Products,Super proizvodi
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +189,Opening Balance Equity,Početno stanje kapital
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +192,Opening Balance Equity,Početno stanje kapital
 DocType: Appraisal,Appraisal,Procjena
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +102,Email sent to supplier {0},E-pošta dostavljati opskrbljivaču {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Datum se ponavlja
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Ovlašteni potpisnik
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +187,Leave approver must be one of {0},Osoba ovlaštena za odobravanje odsustva mora biti jedan od {0}
@@ -2399,7 +2465,7 @@
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Ukupno troškovi nabave (putem kupnje proizvoda)
 DocType: Workstation Working Hour,Start Time,Vrijeme početka
 DocType: Item Price,Bulk Import Help,Bulk uvoz Pomoć
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +199,Select Quantity,Odaberite Količina
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +200,Select Quantity,Odaberite Količina
 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 +66,Unsubscribe from this Email Digest,Odjaviti s ovog Pošalji Digest
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Poslana poruka
@@ -2427,6 +2493,7 @@
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +328,My Shipments,Moje pošiljke
 DocType: Journal Entry,Bill Date,Bill Datum
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +43,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Čak i ako postoji više Cijene pravila s najvišim prioritetom, onda sljedeći interni prioriteti primjenjuje se:"
+DocType: Sales Invoice Item,Total Margin,Ukupna marža
 DocType: Supplier,Supplier Details,Dobavljač Detalji
 DocType: Expense Claim,Approval Status,Status odobrenja
 DocType: Hub Settings,Publish Items to Hub,Objavi artikle u Hub
@@ -2440,7 +2507,7 @@
 apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +33,Customer Group / Customer,Grupa kupaca / Kupac
 DocType: Payment Gateway Account,Default Payment Request Message,Zadana Zahtjev Plaćanje poruku
 DocType: Item Group,Check this if you want to show in website,Označi ovo ako želiš prikazati na webu
-apps/erpnext/erpnext/config/accounts.py +118,Banking and Payments,Bankarstvo i plaćanje
+apps/erpnext/erpnext/config/accounts.py +126,Banking and Payments,Bankarstvo i plaćanje
 ,Welcome to ERPNext,Dobrodošli u ERPNext
 DocType: Payment Reconciliation Payment,Voucher Detail Number,Bon Detalj broj
 apps/erpnext/erpnext/config/crm.py +146,Lead to Quotation,Dovesti do kotaciju
@@ -2448,17 +2515,17 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +37,Calls,Pozivi
 DocType: Project,Total Costing Amount (via Time Logs),Ukupno Obračun troškova Iznos (preko Vrijeme Trupci)
 DocType: Purchase Order Item Supplied,Stock UOM,Kataloški UOM
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +199,Purchase Order {0} is not submitted,Narudžbenicu {0} nije podnesen
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Purchase Order {0} is not submitted,Narudžbenicu {0} nije podnesen
 apps/erpnext/erpnext/stock/doctype/item/item.js +32,Projected,Predviđeno
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,Serial No {0} does not belong to Warehouse {1},Serijski Ne {0} ne pripada Warehouse {1}
-apps/erpnext/erpnext/controllers/status_updater.py +137,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Napomena : Sustav neće provjeravati pretjerano isporuke i više - booking za točku {0} kao količinu ili vrijednost je 0
+apps/erpnext/erpnext/controllers/status_updater.py +139,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Napomena : Sustav neće provjeravati pretjerano isporuke i više - booking za točku {0} kao količinu ili vrijednost je 0
 DocType: Notification Control,Quotation Message,Ponuda - poruka
 DocType: Issue,Opening Date,Datum otvaranja
 DocType: Journal Entry,Remark,Primjedba
 DocType: Purchase Receipt Item,Rate and Amount,Kamatna stopa i iznos
 apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Lišće i odmor
 DocType: Sales Order,Not Billed,Nije naplaćeno
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +107,Both Warehouse must belong to same Company,Oba skladišta moraju pripadati istoj tvrtki
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +115,Both Warehouse must belong to same Company,Oba skladišta moraju pripadati istoj tvrtki
 apps/erpnext/erpnext/public/js/templates/contact_list.html +31,No contacts added yet.,Još uvijek nema dodanih kontakata.
 DocType: Purchase Receipt Item,Landed Cost Voucher Amount,Iznos naloga zavisnog troška
 DocType: Time Log,Batched for Billing,Izmiješane za naplatu
@@ -2474,15 +2541,17 @@
 DocType: Journal Entry Account,Journal Entry Account,Temeljnica račun
 DocType: Shopping Cart Settings,Quotation Series,Ponuda serija
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +53,"An item exists with same name ({0}), please change the item group name or rename the item","Stavka postoji s istim imenom ( {0} ) , molimo promijenite ime stavku grupe ili preimenovati stavku"
+DocType: Company,Asset Depreciation Cost Center,Imovina Centar Amortizacija troškova
 DocType: Sales Order Item,Sales Order Date,Datum narudžbe (kupca)
 DocType: Sales Invoice Item,Delivered Qty,Isporučena količina
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +63,Warehouse {0}: Company is mandatory,Skladište {0}: Kompanija je obvezna
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +266,Purchase Date of asset {0} does not match with Purchase Invoice date,Kupnja Datum imovine {0} ne podudara s datumom kupnje proizvoda
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +71,Warehouse {0}: Company is mandatory,Skladište {0}: Kompanija je obvezna
 ,Payment Period Based On Invoice Date,Razdoblje za naplatu po Datum fakture
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +50,Missing Currency Exchange Rates for {0},Nedostaje Valuta za {0}
 DocType: Journal Entry,Stock Entry,Međuskladišnica
 DocType: Account,Payable,Plativ
 apps/erpnext/erpnext/shopping_cart/cart.py +330,Debtors ({0}),Dužnici ({0})
-DocType: Project,Margin,Marža
+DocType: Pricing Rule,Margin,Marža
 DocType: Salary Slip,Arrear Amount,Iznos unatrag
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Novi kupci
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Gross Profit %,Bruto dobit%
@@ -2490,20 +2559,23 @@
 DocType: Bank Reconciliation Detail,Clearance Date,Razmak Datum
 DocType: Newsletter,Newsletter List,Popis Newsletter
 DocType: Process Payroll,Check if you want to send salary slip in mail to each employee while submitting salary slip,"Provjerite ako želite poslati plaće slip u pošti svakom zaposleniku, dok podnošenje plaće slip"
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +40,Gross Purchase Amount is mandatory,Bruto Iznos narudžbe je obavezno
 DocType: Lead,Address Desc,Adresa silazno
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +33,Atleast one of the Selling or Buying must be selected,Barem jedan od prodajete ili kupujete mora biti odabran
 apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Gdje se odvija proizvodni postupci.
 DocType: Stock Entry Detail,Source Warehouse,Izvor galerija
 DocType: Installation Note,Installation Date,Instalacija Datum
+apps/erpnext/erpnext/controllers/accounts_controller.py +469,Row #{0}: Asset {1} does not belong to company {2},Red # {0}: Imovina {1} ne pripada društvu {2}
 DocType: Employee,Confirmation Date,potvrda Datum
 DocType: C-Form,Total Invoiced Amount,Ukupno Iznos dostavnice
 DocType: Account,Sales User,Prodaja Korisnik
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,Min Qty can not be greater than Max Qty,Minimalna količina ne može biti veća od maksimalne količine
+DocType: Account,Accumulated Depreciation,akumulirana amortizacija
 DocType: Stock Entry,Customer or Supplier Details,Kupca ili dobavljača Detalji
 DocType: Payment Request,Email To,E-mail Da
 DocType: Lead,Lead Owner,Vlasnik potencijalnog kupca
 DocType: Bin,Requested Quantity,Tražena količina
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +253,Warehouse is required,Skladište je potrebno
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +256,Warehouse is required,Skladište je potrebno
 DocType: Employee,Marital Status,Bračni status
 DocType: Stock Settings,Auto Material Request,Auto Materijal Zahtjev
 DocType: Time Log,Will be updated when billed.,Hoće li biti promjena kada je naplaćeno.
@@ -2511,12 +2583,13 @@
 apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +25,Current BOM and New BOM can not be same,Trenutni troškovnik i novi troškovnik ne mogu biti isti
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date Of Retirement must be greater than Date of Joining,Datum umirovljenja mora biti veći od datuma pristupa
 DocType: Sales Invoice,Against Income Account,Protiv računu dohotka
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +69,{0}% Delivered,{0}% Isporučeno
+apps/erpnext/erpnext/controllers/website_list_for_contact.py +84,{0}% Delivered,{0}% Isporučeno
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +79,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Stavka {0}: Ž Količina Jedinična {1} ne može biti manja od minimalne narudžbe kom {2} (definiranom u točki).
 DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Mjesečni postotak distribucije
 DocType: Territory,Territory Targets,Prodajni plan prema teritoriju
 DocType: Delivery Note,Transporter Info,Transporter Info
-DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Narudžbenica artikla Isporuka
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +25,Same supplier has been entered multiple times,Isti dobavljač je unesen više puta
+DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Stavka narudžbenice broj
 apps/erpnext/erpnext/public/js/setup_wizard.js +60,Company Name cannot be Company,Ime tvrtke ne mogu 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, na primjer predračuna."
@@ -2525,17 +2598,18 @@
 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: Payment Request,Payment Details,Pojedinosti o plaćanju
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM stopa
+DocType: Asset,Journal Entry for Scrap,Temeljnica 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 +270,Journal Entries {0} are un-linked,Dnevničkih zapisa {0} su UN-povezani
 apps/erpnext/erpnext/config/crm.py +73,"Record of all communications of type email, phone, chat, visit, etc.","Snimanje svih komunikacija tipa e-mail, telefon, chat, posjete, itd"
 DocType: Manufacturer,Manufacturers used in Items,Proizvođači se koriste u stavkama
 apps/erpnext/erpnext/accounts/general_ledger.py +140,Please mention Round Off Cost Center in Company,Molimo spomenuti zaokružiti troška u Društvu
 DocType: Purchase Invoice,Terms,Uvjeti
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +247,Create New,Kreiraj novi dokument
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +250,Create New,Kreiraj novi dokument
 DocType: Buying Settings,Purchase Order Required,Narudžbenica kupnje je obavezna
 ,Item-wise Sales History,Pregled prometa po artiklu
 DocType: Expense Claim,Total Sanctioned Amount,Ukupno kažnjeni Iznos
-,Purchase Analytics,Kupnja Analytics
+,Purchase Analytics,Analitika nabave
 DocType: Sales Invoice Item,Delivery Note Item,Otpremnica proizvoda
 DocType: Expense Claim,Task,Zadatak
 DocType: Purchase Taxes and Charges,Reference Row #,Reference Row #
@@ -2544,7 +2618,7 @@
 ,Stock Ledger,Glavna knjiga
 apps/erpnext/erpnext/templates/pages/order.html +67,Rate: {0},Ocijenite: {0}
 DocType: Salary Slip Deduction,Salary Slip Deduction,Plaća proklizavanja Odbitak
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +198,Select a group node first.,Odaberite grupu čvor na prvom mjestu.
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +201,Select a group node first.,Odaberite grupu čvor na prvom mjestu.
 apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Zaposlenika i posjećenost
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +73,Purpose must be one of {0},Svrha mora biti jedna od {0}
 apps/erpnext/erpnext/utilities/doctype/address/address.py +78,"Remove reference of customer, supplier, sales partner and lead, as it is your company address","Uklonite referencu kupac, dobavljač, prodaje partnera i olova, kao što je vaša adresa tvrtke"
@@ -2566,13 +2640,14 @@
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: od {1}
 DocType: Task,depends_on,ovisi o
 DocType: Features Setup,"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Popust polja će biti dostupna u narudžbenici, primci i računu kupnje"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +207,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Naziv novog računa. Napomena: Molimo vas da ne stvaraju račune za kupce i dobavljače
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +210,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Naziv novog računa. Napomena: Molimo vas da ne stvaraju račune za kupce i dobavljače
 DocType: BOM Replace Tool,BOM Replace Tool,BOM zamijeni alat
 apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Država mudar zadana adresa predlošci
 DocType: Sales Order Item,Supplier delivers to Customer,Dobavljač dostavlja Kupcu
-apps/erpnext/erpnext/controllers/recurring_document.py +173,Next Date must be greater than Posting Date,Sljedeći datum mora biti veći od datum knjiženja
-apps/erpnext/erpnext/public/js/controllers/transaction.js +766,Show tax break-up,Pokaži porez raspada
-apps/erpnext/erpnext/accounts/party.py +283,Due / Reference Date cannot be after {0},Zbog / Referentni datum ne može biti nakon {0}
+apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Obrazac / Artikl / {0}) je out of stock
+apps/erpnext/erpnext/controllers/recurring_document.py +174,Next Date must be greater than Posting Date,Sljedeći datum mora biti veći od datum knjiženja
+apps/erpnext/erpnext/public/js/controllers/transaction.js +777,Show tax break-up,Pokaži porez raspada
+apps/erpnext/erpnext/accounts/party.py +289,Due / Reference Date cannot be after {0},Zbog / Referentni datum ne može biti nakon {0}
 apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Uvoz i izvoz podataka
 DocType: Features Setup,If you involve in manufacturing activity. Enables Item 'Is Manufactured',Ako uključiti u proizvodnom djelatnošću . Omogućuje stavci je proizveden '
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +54,Invoice Posting Date,Račun knjiženja Datum
@@ -2587,7 +2662,7 @@
 apps/erpnext/erpnext/config/accounts.py +45,Company (not Customer or Supplier) master.,Društvo ( ne kupaca i dobavljača ) majstor .
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +101,Please enter 'Expected Delivery Date',Unesite ' Očekivani datum isporuke '
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +181,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/accounts/doctype/sales_invoice/sales_invoice.py +379,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/accounts/doctype/sales_invoice/sales_invoice.py +372,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 +80,{0} is not a valid Batch Number for Item {1},{0} nije ispravan broj serije za točku {1}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +128,Note: There is not enough leave balance for Leave Type {0},Napomena : Nema dovoljno ravnotežu dopust za dozvolu tipa {0}
 apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +9,"Note: If payment is not made against any reference, make Journal Entry manually.","Napomena: Ukoliko uplata nije izvršena protiv bilo referencu, provjerite Temeljnica ručno."
@@ -2601,7 +2676,7 @@
 DocType: Hub Settings,Publish Availability,Objavi dostupnost
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +109,Date of Birth cannot be greater than today.,Datum rođenja ne može biti veća nego danas.
 ,Stock Ageing,Starost skladišta
-apps/erpnext/erpnext/controllers/accounts_controller.py +213,{0} '{1}' is disabled,{0} '{1}' je onemogućen
+apps/erpnext/erpnext/controllers/accounts_controller.py +219,{0} '{1}' is disabled,{0} '{1}' je onemogućen
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Postavi kao Opena
 DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Pošaljite e-poštu automatski u imenik na podnošenje transakcija.
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +229,"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
@@ -2611,7 +2686,7 @@
 DocType: Purchase Order,Customer Contact Email,Kupac Kontakt e
 DocType: Warranty Claim,Item and Warranty Details,Stavka i jamstvo Detalji
 DocType: Sales Team,Contribution (%),Doprinos (%)
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +469,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/accounts/doctype/sales_invoice/sales_invoice.py +473,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/setup/setup_wizard/install_fixtures.py +171,Responsibilities,Odgovornosti
 apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Template,Predložak
 DocType: Sales Person,Sales Person Name,Ime prodajne osobe
@@ -2622,7 +2697,7 @@
 DocType: Stock Reconciliation Item,Before reconciliation,Prije pomirenja
 apps/erpnext/erpnext/support/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 +378,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 +383,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
 DocType: Item,Default BOM,Zadani BOM
 apps/erpnext/erpnext/setup/doctype/company/company.js +44,Please re-type company name to confirm,Ponovno upišite naziv tvrtke za potvrdu
@@ -2631,11 +2706,12 @@
 DocType: Journal Entry,Printing Settings,Ispis Postavke
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +265,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
+DocType: Asset Category Account,Fixed Asset Account,Fiksni račun imovinom
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +50,From Delivery Note,Od otpremnici
 DocType: Time Log,From Time,S vremena
 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/sales_invoice/sales_invoice.py +375,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/accounts/doctype/sales_invoice/sales_invoice.py +368,Cash or Bank Account is mandatory for making payment entry,Novac ili bankovni račun je obvezna za izradu ulazak plaćanje
 DocType: Purchase Invoice,Price List Exchange Rate,Tečaj cjenika
 DocType: Purchase Invoice Item,Rate,VPC
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Intern,stažista
@@ -2643,7 +2719,7 @@
 DocType: Stock Entry,From BOM,Od sastavnice
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +34,Basic,Osnovni
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +96,Stock transactions before {0} are frozen,Stock transakcije prije {0} se zamrznut
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +204,Please click on 'Generate Schedule',"Molimo kliknite na ""Generiraj raspored '"
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +208,Please click on 'Generate Schedule',"Molimo kliknite na ""Generiraj raspored '"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +63,To Date should be same as From Date for Half Day leave,Za datum bi trebao biti isti kao i od datuma za poludnevni dopust
 apps/erpnext/erpnext/config/stock.py +186,"e.g. Kg, Unit, Nos, m","npr. kg, kom, br, m"
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +95,Reference No is mandatory if you entered Reference Date,Reference Ne obvezno ako ušao referentnog datuma
@@ -2651,17 +2727,17 @@
 apps/erpnext/erpnext/hr/doctype/employee/employee.js +29,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 +612,Issue Material,Izdavanje materijala
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +615,Issue Material,Izdavanje materijala
 DocType: Material Request Item,For Warehouse,Za galeriju
 DocType: Employee,Offer Date,Datum ponude
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Citati
 DocType: Hub Settings,Access Token,Pristup token
 DocType: Sales Invoice Item,Serial No,Serijski br
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +131,Please enter Maintaince Details first,Unesite prva Maintaince Detalji
-DocType: Item,Is Fixed Asset Item,Je fiksne imovine stavku
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +135,Please enter Maintaince Details first,Unesite prva Maintaince Detalji
 DocType: Purchase Invoice,Print Language,Ispis Language
 DocType: Stock Entry,Including items for sub assemblies,Uključujući predmeta za sub sklopova
 DocType: Features Setup,"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Ako ste dugo ispis formata, ova značajka može se koristiti za podijeliti stranicu na koju se ispisuje više stranica sa svim zaglavljima i podnožjima na svakoj stranici"
+DocType: Asset,Number of Depreciations,Broj deprecijaciju
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +98,All Territories,Sve teritorije
 DocType: Purchase Invoice,Items,Proizvodi
 DocType: Fiscal Year,Year Name,Naziv godine
@@ -2669,19 +2745,21 @@
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +77,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 bala predmeta
 DocType: Sales Partner,Sales Partner Name,Naziv prodajnog partnera
+apps/erpnext/erpnext/hooks.py +86,Request for Quotations,Zahtjev za dostavljanje ponuda
 DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimalna Iznos dostavnice
 DocType: Purchase Invoice Item,Image View,Prikaz slike
 apps/erpnext/erpnext/config/selling.py +23,Customers,Kupci
+DocType: Asset,Partially Depreciated,djelomično amortiziraju
 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 +540,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Zadana mjerna jedinica za Variant &#39;{0}&#39; mora biti isti kao u predložak &#39;{1}&#39;
+apps/erpnext/erpnext/stock/doctype/item/item.py +545,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Zadana mjerna jedinica za Variant &#39;{0}&#39; mora biti isti kao u predložak &#39;{1}&#39;
 DocType: Shipping Rule,Calculate Based On,Izračun temeljen na
 DocType: Delivery Note Item,From Warehouse,Iz skladišta
 DocType: Purchase Taxes and Charges,Valuation and Total,Vrednovanje i Total
 DocType: Tax Rule,Shipping City,Dostava Grad
 apps/erpnext/erpnext/stock/doctype/item/item.js +59,This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,"Ova točka je varijanta {0} (predložak). Značajke će biti kopirana iz predloška, osim ako je postavljen 'Ne Kopiraj'"
-DocType: Account,Purchase User,Kupnja Korisnik
+DocType: Account,Purchase User,Korisnik nabave
 DocType: Notification Control,Customize the Notification,Prilagodi obavijest
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +17,Cash Flow from Operations,Novčani tijek iz redovnog poslovanja
 apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +27,Default Address Template cannot be deleted,Zadani predložak adrese ne može se izbrisati
@@ -2691,13 +2769,13 @@
 DocType: Quotation,Maintenance Manager,Upravitelj održavanja
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +54,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,'Dani od posljednje narudžbe' mora biti veći ili jednak nuli
-DocType: C-Form,Amended From,Izmijenjena Od
+DocType: Asset,Amended From,Izmijenjena Od
 apps/erpnext/erpnext/public/js/setup_wizard.js +269,Raw Material,sirovine
 DocType: Leave Application,Follow via Email,Slijedite putem e-maila
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Iznos poreza Nakon iznosa popusta
-apps/erpnext/erpnext/accounts/doctype/account/account.py +198,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 .
+apps/erpnext/erpnext/accounts/doctype/account/account.py +195,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 .
 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 +486,No default BOM exists for Item {0},Zadani BOM ne postoji za proizvod {0}
+apps/erpnext/erpnext/stock/get_item_details.py +484,No default BOM exists for Item {0},Zadani BOM ne postoji za proizvod {0}
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +325,Please select Posting Date first,Molimo odaberite datum knjiženja prvo
 apps/erpnext/erpnext/public/js/account_tree_grid.js +211,Opening Date should be before Closing Date,Otvaranje Datum bi trebao biti prije datuma zatvaranja
 DocType: Leave Control Panel,Carry Forward,Prenijeti
@@ -2710,21 +2788,22 @@
 apps/erpnext/erpnext/public/js/setup_wizard.js +143,Attach Letterhead,Pričvrstite zaglavljem
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +272,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/public/js/setup_wizard.js +191,"List your tax heads (e.g. VAT, Customs etc; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Popis svoje porezne glave (npr PDV, carina itd, oni bi trebali imati jedinstvene nazive) i njihove standardne stope. To će stvoriti standardni predložak koji možete uređivati i dodavati više kasnije."
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +460,Please mention 'Gain/Loss Account on Asset Disposal' in Company,Molimo spomenuti &#39;dobici / gubici računa na sredstva Odlaganje&#39; u društvu
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +230,Serial Nos Required for Serialized Item {0},Serijski Nos potrebna za serijaliziranom točke {0}
-apps/erpnext/erpnext/config/accounts.py +133,Match Payments with Invoices,Match Plaćanja s faktura
+apps/erpnext/erpnext/config/accounts.py +141,Match Payments with Invoices,Match Plaćanja s faktura
 DocType: Journal Entry,Bank Entry,Bank Stupanje
 DocType: Authorization Rule,Applicable To (Designation),Odnosi se na (Oznaka)
 apps/erpnext/erpnext/templates/generators/item.html +68,Add to Cart,Dodaj u košaricu
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Grupa Do
-apps/erpnext/erpnext/config/accounts.py +235,Enable / disable currencies.,Omogućiti / onemogućiti valute .
+apps/erpnext/erpnext/config/accounts.py +243,Enable / disable currencies.,Omogućiti / onemogućiti valute .
 DocType: Production Planning Tool,Get Material Request,Dobiti materijala zahtjev
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +114,Postal Expenses,Poštanski troškovi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,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
 DocType: Quality Inspection,Item Serial No,Serijski broj proizvoda
-apps/erpnext/erpnext/controllers/status_updater.py +143,{0} must be reduced by {1} or you should increase overflow tolerance,{0} mora biti smanjena za {1} ili bi trebali povećati overflow toleranciju
+apps/erpnext/erpnext/controllers/status_updater.py +145,{0} must be reduced by {1} or you should increase overflow tolerance,{0} mora biti smanjena za {1} ili bi trebali povećati overflow toleranciju
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Present,Ukupno Present
-apps/erpnext/erpnext/config/accounts.py +89,Accounting Statements,Računovodstveni izvještaji
+apps/erpnext/erpnext/config/accounts.py +97,Accounting Statements,Računovodstveni izvještaji
 apps/erpnext/erpnext/public/js/setup_wizard.js +273,Hour,Sat
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +145,"Serialized Item {0} cannot be updated \
 					using Stock Reconciliation","Serijaliziranom Stavka {0} nije moguće ažurirati pomoću \
@@ -2744,15 +2823,16 @@
 DocType: C-Form,Invoices,Računi
 DocType: Job Opening,Job Title,Titula
 DocType: Features Setup,Item Groups in Details,Grupe proizvoda detaljno
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,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 +348,Quantity to Manufacture must be greater than 0.,Količina za proizvodnju mora biti veći od 0.
 apps/erpnext/erpnext/accounts/page/pos/pos.js +4,Start Point-of-Sale (POS),Početak Point-of-Sale (POS)
 apps/erpnext/erpnext/config/support.py +32,Visit report for maintenance call.,Pogledajte izvješće razgovora vezanih uz održavanje.
 DocType: Stock Entry,Update Rate and Availability,Brzina ažuriranja i dostupnost
 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: Pricing Rule,Customer Group,Grupa kupaca
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +169,Expense account is mandatory for item {0},Rashodi račun je obvezna za predmet {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Expense account is mandatory for item {0},Rashodi račun je obvezna za predmet {0}
 DocType: Item,Website Description,Opis web stranice
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Net Change in Equity,Neto promjena u kapitalu
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +94,Please cancel Purchase Invoice {0} first,Otkažite fakturi {0} prvi
 DocType: Serial No,AMC Expiry Date,AMC Datum isteka
 ,Sales Register,Prodaja Registracija
 DocType: Quotation,Quotation Lost Reason,Razlog nerealizirane ponude
@@ -2760,12 +2840,13 @@
 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/setup/doctype/email_digest/email_digest.py +108,Summary for this month and pending activities,Sažetak za ovaj mjesec i tijeku aktivnosti
 DocType: Customer Group,Customer Group Name,Naziv grupe kupaca
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +416,Please remove this Invoice {0} from C-Form {1},Molimo uklonite ovu fakturu {0} od C-obrasca {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +409,Please remove this Invoice {0} from C-Form {1},Molimo uklonite ovu fakturu {0} od C-obrasca {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
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +666,Error: {0} &gt; {1},Pogreška: {0}&gt; {1}
 DocType: Item,Attributes,Značajke
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +519,Get Items,Kreiraj proizvode
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +192,Please enter Write Off Account,Unesite otpis račun
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +522,Get Items,Kreiraj proizvode
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +194,Please enter Write Off Account,Unesite otpis račun
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Zadnje narudžbe Datum
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +39,Account {0} does not belongs to company {1},Račun {0} ne pripada društvu {1}
 DocType: C-Form,C-Form,C-obrazac
@@ -2777,18 +2858,18 @@
 DocType: Purchase Invoice,Mobile No,Mobitel br
 DocType: Payment Tool,Make Journal Entry,Provjerite Temeljnica
 DocType: Leave Allocation,New Leaves Allocated,Novi Leaves Dodijeljeni
-apps/erpnext/erpnext/controllers/trends.py +261,Project-wise data is not available for Quotation,Projekt - mudar podaci nisu dostupni za ponudu
+apps/erpnext/erpnext/controllers/trends.py +265,Project-wise data is not available for Quotation,Projekt - mudar podaci nisu dostupni za ponudu
 DocType: Project,Expected End Date,Očekivani Datum završetka
 DocType: Appraisal Template,Appraisal Template Title,Procjena Predložak Naslov
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +343,Commercial,trgovački
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +663,Error: {0} &gt; {1},Pogreška: {0}&gt; {1}
 apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Roditelj Stavka {0} ne smije biti kataloški predmeta
 DocType: Cost Center,Distribution Id,ID distribucije
 apps/erpnext/erpnext/setup/setup_wizard/data/sample_home_page.html +14,Awesome Services,Super usluge
 apps/erpnext/erpnext/config/manufacturing.py +52,All Products or Services.,Svi proizvodi i usluge.
 DocType: Supplier Quotation,Supplier Address,Dobavljač Adresa
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +505,Row {0}# Account must be of type 'Fixed Asset',Red {0} # računa mora biti tipa &#39;Dugotrajne imovine&#39;
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Out Qty,Od kol
-apps/erpnext/erpnext/config/accounts.py +251,Rules to calculate shipping amount for a sale,Pravila za izračun shipping iznos za prodaju
+apps/erpnext/erpnext/config/accounts.py +259,Rules to calculate shipping amount for a sale,Pravila za izračun shipping iznos za prodaju
 apps/erpnext/erpnext/selling/doctype/customer/customer.py +29,Series is mandatory,Serija je obvezno
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,Financijske usluge
 apps/erpnext/erpnext/controllers/item_variant.py +62,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3},Vrijednost za Osobina {0} mora biti u rasponu od {1} {2} u koracima od {3}
@@ -2799,17 +2880,17 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +145,Cr,Cr
 DocType: Customer,Default Receivable Accounts,Default receivable račune
 DocType: Tax Rule,Billing State,Državna naplate
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +637,Transfer,Prijenos
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +681,Fetch exploded BOM (including sub-assemblies),Fetch eksplodirala BOM (uključujući i podsklopova )
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +640,Transfer,Prijenos
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +688,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 +92,Due Date is mandatory,Datum dospijeća je obavezno
+apps/erpnext/erpnext/controllers/accounts_controller.py +93,Due Date is mandatory,Datum dospijeća je obavezno
 apps/erpnext/erpnext/controllers/item_variant.py +52,Increment for Attribute {0} cannot be 0,Pomak za Osobina {0} ne može biti 0
 DocType: Journal Entry,Pay To / Recd From,Platiti do / primiti od
 DocType: Naming Series,Setup Series,Postavljanje Serija
 DocType: Payment Reconciliation,To Invoice Date,Za Račun Datum
 DocType: Supplier,Contact HTML,Kontakt HTML
 ,Inactive Customers,Neaktivni korisnici
-DocType: Landed Cost Voucher,Purchase Receipts,Kupnja Primici
+DocType: Landed Cost Voucher,Purchase Receipts,Primke
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +27,How Pricing Rule is applied?,Kako se primjenjuje pravilo cijena?
 DocType: Quality Inspection,Delivery Note No,Otpremnica br
 DocType: Company,Retail,Maloprodaja
@@ -2817,25 +2898,27 @@
 DocType: Attendance,Absent,Odsutan
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +439,Product Bundle,Snop proizvoda
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +185,Row {0}: Invalid reference {1},Red {0}: Pogrešna referentni {1}
-DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kupnja poreze i pristojbe predloška
+DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Predložak nabavnih poreza i terećenja
 DocType: Upload Attendance,Download Template,Preuzmite predložak
 DocType: GL Entry,Remarks,Primjedbe
 DocType: Purchase Order Item Supplied,Raw Material Item Code,Sirovine Stavka Šifra
 DocType: Journal Entry,Write Off Based On,Otpis na temelju
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +602,Send Supplier Emails,Pošalji Supplier e-pošte
 DocType: Features Setup,POS View,Prodajno mjesto prikaz
 apps/erpnext/erpnext/config/stock.py +123,Installation record for a Serial No.,Instalacijski zapis za serijski broj
-apps/erpnext/erpnext/controllers/recurring_document.py +176,Next Date's day and Repeat on Day of Month must be equal,Sljedeći datum dan i ponavljanja na dan u mjesecu mora biti jednaka
+apps/erpnext/erpnext/controllers/recurring_document.py +187,Next Date's day and Repeat on Day of Month must be equal,Sljedeći datum dan i ponavljanja na dan u mjesecu mora biti jednaka
 apps/erpnext/erpnext/public/js/queries.js +39,Please specify a,Navedite
 DocType: Offer Letter,Awaiting Response,Očekujem odgovor
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +53,Above,Iznad
 apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +40,Time Log has been Billed,Vrijeme Prijavite se Naplaćeno
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +187,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Molimo postavite Imenovanje serija za {0} preko Postavljanje&gt; Postavke&gt; imenujući serije
 DocType: Salary Slip,Earning & Deduction,Zarada &amp; Odbitak
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +73,Account {0} cannot be a Group,Račun {0} ne može biti grupa
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +215,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/accounts/page/accounts_browser/accounts_browser.js +218,Optional. This setting will be used to filter in various transactions.,Izborni . Ova postavka će se koristiti za filtriranje u raznim transakcijama .
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +111,Negative Valuation Rate is not allowed,Negativna stopa vrijednovanja nije dopuštena
 DocType: Holiday List,Weekly Off,Tjedni Off
 DocType: Fiscal Year,"For e.g. 2012, 2012-13","Za npr. 2012, 2012-13"
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +35,Provisional Profit / Loss (Credit),Privremeni dobit / gubitak (Credit)
+apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Provisional Profit / Loss (Credit),Privremeni dobit / gubitak (Credit)
 DocType: Sales Invoice,Return Against Sales Invoice,Povratak protiv prodaje fakturu
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Stavka 5
 apps/erpnext/erpnext/accounts/utils.py +278,Please set default value {0} in Company {1},Molimo postavite zadanu vrijednost {0} u Društvu {1}
@@ -2845,12 +2928,13 @@
 ,Monthly Attendance Sheet,Mjesečna lista posjećenosti
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +16,No record found,Nije pronađen zapis
 apps/erpnext/erpnext/controllers/stock_controller.py +176,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Mjesto troška je ovezno za stavku {2}
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +87,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Molimo postavljanje broje serija za sudjelovanje putem Podešavanje&gt; numeriranja Serija
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +501,Get Items from Product Bundle,Se predmeti s Bundle proizvoda
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +504,Get Items from Product Bundle,Se predmeti s Bundle proizvoda
+DocType: Asset,Straight Line,Ravna crta
+DocType: Project User,Project User,Korisnik projekta
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +76,Account {0} is inactive,Račun {0} nije aktivan
 DocType: GL Entry,Is Advance,Je Predujam
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Gledanost od datuma do datuma je obvezna
-apps/erpnext/erpnext/controllers/buying_controller.py +122,Please enter 'Is Subcontracted' as Yes or No,Unesite ' Je podugovoren ' kao da ili ne
+apps/erpnext/erpnext/controllers/buying_controller.py +123,Please enter 'Is Subcontracted' as Yes or No,Unesite ' Je podugovoren ' kao da ili ne
 DocType: Sales Team,Contact No.,Kontakt broj
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +64,'Profit and Loss' type account {0} not allowed in Opening Entry,'Račun dobiti i gubitka' tip računa {0} nije dopušten u otvorenom ulazu
 DocType: Features Setup,Sales Discounts,Prodajni popusti
@@ -2864,39 +2948,40 @@
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Broj narudžbe
 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,Navedite uvjete za izračunavanje iznosa dostave
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +117,Add Child,Dodaj dijete
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +120,Add Child,Dodaj dijete
 DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Uloga dopušteno postavljanje blokada računa i uređivanje Frozen Entries
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +52,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 +47,Opening Value,Otvaranje vrijednost
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +37,Serial #,Serijski #
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +87,Commission on Sales,Komisija za prodaju
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +90,Commission on Sales,Komisija za prodaju
 DocType: Offer Letter Term,Value / Description,Vrijednost / Opis
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +492,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Red # {0}: Imovina {1} ne može se podnijeti, to je već {2}"
 DocType: Tax Rule,Billing Country,Naplata Država
 ,Customers Not Buying Since Long Time,Kupci koji nisu kupili već dugo vremena
 DocType: Production Order,Expected Delivery Date,Očekivani rok isporuke
 apps/erpnext/erpnext/accounts/general_ledger.py +127,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debitne i kreditne nije jednaka za {0} # {1}. Razlika je {2}.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Entertainment Expenses,Zabava Troškovi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +96,Entertainment Expenses,Zabava Troškovi
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +189,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/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +61,Age,Doba
 DocType: Time Log,Billing Amount,Naplata 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.
 apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Prijave za odmor.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +196,Account with existing transaction can not be deleted,Račun s postojećom transakcijom ne može se izbrisati
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Legal Expenses,Pravni troškovi
+apps/erpnext/erpnext/accounts/doctype/account/account.py +193,Account with existing transaction can not be deleted,Račun s postojećom transakcijom ne može se izbrisati
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Pravni troškovi
 DocType: Sales Invoice,Posting Time,Objavljivanje Vrijeme
 DocType: Sales Order,% Amount Billed,% Naplaćeni iznos
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Telephone Expenses,Telefonski troškovi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,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 +118,No Item with Serial No {0},Nema proizvoda sa serijskim brojem {0}
+apps/erpnext/erpnext/stock/get_item_details.py +117,No Item with Serial No {0},Nema proizvoda sa serijskim brojem {0}
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +95,Open Notifications,Otvoreno Obavijesti
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Direct Expenses,Izravni troškovi
-apps/erpnext/erpnext/controllers/recurring_document.py +200,"{0} is an invalid email address in 'Notification \
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Direct Expenses,Izravni troškovi
+apps/erpnext/erpnext/controllers/recurring_document.py +210,"{0} is an invalid email address in 'Notification \
 						Email Address'",{0} nije ispravan e-mail adresu u &quot;Obavijest \ e-mail adresa &#39;
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Novi prihod kupca
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Travel Expenses,putni troškovi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Travel Expenses,putni troškovi
 DocType: Maintenance Visit,Breakdown,Slom
-apps/erpnext/erpnext/controllers/accounts_controller.py +527,Account: {0} with currency: {1} can not be selected,Račun: {0} s valutom: {1} ne može se odabrati
+apps/erpnext/erpnext/controllers/accounts_controller.py +553,Account: {0} with currency: {1} can not be selected,Račun: {0} s valutom: {1} ne može se odabrati
 DocType: Bank Reconciliation Detail,Cheque Date,Ček Datum
 apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Račun {0}: nadređeni račun {1} ne pripada tvrtki: {2}
 apps/erpnext/erpnext/setup/doctype/company/company.js +60,Successfully deleted all transactions related to this company!,Uspješno izbrisati sve transakcije vezane uz ovu tvrtku!
@@ -2913,7 +2998,7 @@
 DocType: Project,Total Billing Amount (via Time Logs),Ukupno naplate Iznos (preko Vrijeme Trupci)
 apps/erpnext/erpnext/public/js/setup_wizard.js +275,We sell this Item,Prodajemo ovaj proizvod
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +65,Supplier Id,Id Dobavljač
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +205,Quantity should be greater than 0,Količina bi trebala biti veća od 0
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +214,Quantity should be greater than 0,Količina bi trebala biti veća od 0
 DocType: Journal Entry,Cash Entry,Novac Stupanje
 DocType: Sales Partner,Contact Desc,Kontakt ukratko
 apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Tip lišća poput casual, bolovanja i sl."
@@ -2924,11 +3009,12 @@
 DocType: Production Order,Total Operating Cost,Ukupni trošak
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +150,Note: Item {0} entered multiple times,Napomena : Proizvod {0} je upisan više puta
 apps/erpnext/erpnext/config/crm.py +27,All Contacts.,Svi kontakti.
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +270,Supplier of asset {0} does not match with the supplier in the Purchase Invoice,Dobavljač imovine {0} ne podudara s dobavljačem na fakturi
 DocType: Newsletter,Test Email Id,Test E-mail ID
 apps/erpnext/erpnext/public/js/setup_wizard.js +19,Company Abbreviation,Kratica Društvo
 DocType: Features Setup,If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Ako slijedite kvalitete . Omogućuje predmet QA potrebno i QA Ne u Račun kupnje
 DocType: GL Entry,Party Type,Tip stranke
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +71,Raw material cannot be same as main Item,Sirovina ne mogu biti isti kao glavni predmet
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +80,Raw material cannot be same as main Item,Sirovina ne mogu biti isti kao glavni predmet
 DocType: Item Attribute Value,Abbreviation,Skraćenica
 apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Niste ovlašteni od {0} prijeđenog limita
 apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Plaća predložak majstor .
@@ -2944,28 +3030,29 @@
 DocType: Stock Settings,Role Allowed to edit frozen stock,Uloga dopuštenih urediti smrznute zalihe
 ,Territory Target Variance Item Group-Wise,Pregled prometa po teritoriji i grupi proizvoda
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +101,All Customer Groups,Sve grupe kupaca
-apps/erpnext/erpnext/controllers/accounts_controller.py +488,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obavezno. Možda Mjenjačnica zapis nije stvoren za {1} na {2}.
+apps/erpnext/erpnext/controllers/accounts_controller.py +514,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je obavezno. Možda Mjenjačnica zapis nije stvoren za {1} na {2}.
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +37,Tax Template is mandatory.,Porez Predložak je obavezno.
 apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Račun {0}: nadređeni račun {1} ne postoji
 DocType: Purchase Invoice Item,Price List Rate (Company Currency),Stopa cjenika (valuta tvrtke)
 DocType: Account,Temporary,Privremen
 DocType: Address,Preferred Billing Address,Željena adresa za naplatu
+apps/erpnext/erpnext/accounts/party.py +238,Billing currency must be equal to either default comapany's currency or party's payble account currency,Valuta naplate mora biti jednaka Zadano comapany valute ili payble valutu stranke
 DocType: Monthly Distribution Percentage,Percentage Allocation,Postotak raspodjele
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Secretary,tajnica
 DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Ako onemogućite &quot;, riječima &#39;polja neće biti vidljiva u bilo koju transakciju"
 DocType: Serial No,Distinct unit of an Item,Razlikuje jedinica stavku
-DocType: Pricing Rule,Buying,Kupnja
+DocType: Pricing Rule,Buying,Nabava
 DocType: HR Settings,Employee Records to be created by,Zaposlenik Records bi se stvorili
 apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +24,This Time Log Batch has been cancelled.,Ovo Batch Vrijeme Log je otkazan.
 ,Reqd By Date,Reqd Po datumu
 DocType: Salary Slip Earning,Salary Slip Earning,Plaća proklizavanja Zarada
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +161,Creditors,Vjerovnici
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +164,Creditors,Vjerovnici
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +94,Row # {0}: Serial No is mandatory,Red # {0}: Serijski br obvezno
 DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Stavka Wise Porezna Detalj
 ,Item-wise Price List Rate,Item-wise cjenik
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +721,Supplier Quotation,Dobavljač Ponuda
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +724,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/stock/doctype/item/item.py +390,Barcode {0} already used in Item {1},Barkod {0} se već koristi u proizvodu {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +395,Barcode {0} already used in Item {1},Barkod {0} se već koristi u proizvodu {1}
 DocType: Lead,Add to calendar on this date,Dodaj u kalendar na ovaj datum
 apps/erpnext/erpnext/config/stock.py +97,Rules for adding shipping costs.,Pravila za dodavanje troškova prijevoza.
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +40,Upcoming Events,Nadolazeći događaji
@@ -2986,15 +3073,14 @@
 DocType: Customer,From Lead,Od Olovo
 apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Narudžbe objavljen za proizvodnju.
 apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +42,Select Fiscal Year...,Odaberite fiskalnu godinu ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +456,POS Profile required to make POS Entry,POS Profil potrebna da bi POS unos
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +449,POS Profile required to make POS Entry,POS Profil potrebna da bi POS unos
 DocType: Hub Settings,Name Token,Naziv tokena
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +106,Standard Selling,Standardna prodaja
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +136,Atleast one warehouse is mandatory,Atleast jednom skladištu je obavezno
 DocType: Serial No,Out of Warranty,Od jamstvo
 DocType: BOM Replace Tool,Replace,Zamijeniti
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +330,{0} against Sales Invoice {1},{0} u odnosu na prodajnom računu {1}
-apps/erpnext/erpnext/stock/doctype/item/item.py +59,Please enter default Unit of Measure,Unesite zadanu jedinicu mjere
-DocType: Project,Project Name,Naziv projekta
+DocType: Request for Quotation Item,Project Name,Naziv projekta
 DocType: Supplier,Mention if non-standard receivable account,Spomenuti ako nestandardni potraživanja račun
 DocType: Journal Entry Account,If Income or Expense,Ako prihoda i rashoda
 DocType: Features Setup,Item Batch Nos,Broj serije proizvoda
@@ -3024,6 +3110,7 @@
 DocType: Sales Invoice,End Date,Datum završetka
 apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Stock transakcije
 DocType: Employee,Internal Work History,Unutarnja Povijest Posao
+DocType: Depreciation Schedule,Accumulated Depreciation Amount,Akumulirana amortizacija iznos
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Private Equity
 DocType: Maintenance Visit,Customer Feedback,Kupac Ocjena
 DocType: Account,Expense,rashod
@@ -3031,7 +3118,7 @@
 apps/erpnext/erpnext/utilities/doctype/address/address.py +76,"Company is mandatory, as it is your company address","Društvo je obvezno, kao što je vaša adresa tvrtke"
 DocType: Item Attribute,From Range,Iz raspona
 apps/erpnext/erpnext/stock/utils.py +89,Item {0} ignored since it is not a stock item,Proizvod {0} se ignorira budući da nije skladišni artikal
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +29,Submit this Production Order for further processing.,Pošaljite ovaj radnog naloga za daljnju obradu .
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +30,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 +21,"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: Company,Domain,Domena
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +23,Jobs,Posao
@@ -3043,6 +3130,7 @@
 DocType: Time Log,Additional Cost,Dodatni trošak
 apps/erpnext/erpnext/public/js/setup_wizard.js +41,Financial Year End Date,Financijska godina - zadnji datum
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"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 +599,Make Supplier Quotation,Napravi ponudu dobavljaču
 DocType: Quality Inspection,Incoming,Dolazni
 DocType: BOM,Materials Required (Exploded),Potrebna roba
 DocType: Salary Structure Earning,Reduce Earning for Leave Without Pay (LWP),Smanjenje plaća za ostaviti bez plaće (lwp)
@@ -3059,10 +3147,11 @@
 DocType: Sales Order,Delivery Date,Datum isporuke
 DocType: Opportunity,Opportunity Date,Datum prilike
 DocType: Purchase Receipt,Return Against Purchase Receipt,Povratak na primku
+DocType: Request for Quotation Item,Request for Quotation Item,Zahtjev za ponudu točke
 DocType: Purchase Order,To Bill,Za Billa
 DocType: Material Request,% Ordered,% Naručeno
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +61,Piecework,Rad po komadu
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Avg. Buying Rate,AVG. Kupnja stopa
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Avg. Buying Rate,Prosječna nabavna cijena
 DocType: Task,Actual Time (in Hours),Stvarno vrijeme (u satima)
 DocType: Employee,History In Company,Povijest tvrtke
 apps/erpnext/erpnext/config/crm.py +151,Newsletters,Newsletteri
@@ -3073,11 +3162,12 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +188,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,Postavke računa
 DocType: Customer,Sales Partner and Commission,Prodaja partner i komisija
+apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +168,Please set 'Asset Disposal Account' in Company {0},Molimo postavite &quot;Asset račun Odlaganje &#39;u Društvu {0}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +53,Plant and Machinery,Postrojenja i strojevi
 DocType: Sales Partner,Partner's Website,Web stranica partnera
 DocType: Opportunity,To Discuss,Za Raspravljajte
 DocType: SMS Settings,SMS Settings,SMS postavke
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +60,Temporary Accounts,Privremeni računi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +63,Temporary Accounts,Privremeni računi
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +155,Black,Crna
 DocType: BOM Explosion Item,BOM Explosion Item,BOM eksplozije artikla
 DocType: Account,Auditor,Revizor
@@ -3085,22 +3175,23 @@
 DocType: Production Order Operation,Production Order Operation,Proizvodni nalog Rad
 DocType: Pricing Rule,Disable,Ugasiti
 DocType: Project Task,Pending Review,U tijeku pregled
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +132, Click here to pay,Kliknite ovdje za plačanje
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +132, Click here to pay,Kliknite ovdje za plaćanje
+apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +101,"Asset {0} cannot be scrapped, as it is already {1}","Imovina {0} ne može biti otpisan, kao što je već {1}"
 DocType: Task,Total Expense Claim (via Expense Claim),Ukupni rashodi Zatraži (preko Rashodi Zahtjeva)
 apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py +66,Customer Id,Korisnički ID
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +176,Mark Absent,Mark Odsutni
 apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +107,To Time must be greater than From Time,Za vrijeme mora biti veći od od vremena
 DocType: Journal Entry Account,Exchange Rate,Tečaj
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +479,Sales Order {0} is not submitted,Prodajnog naloga {0} nije podnesen
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +719,Add items from,Dodavanje stavki iz
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0}: Parent account {1} does not bolong to the company {2},Skladište {0}: Nadređeni račun {1} ne pripada tvrtki {2}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +483,Sales Order {0} is not submitted,Prodajnog naloga {0} nije podnesen
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +722,Add items from,Dodavanje stavki iz
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +82,Warehouse {0}: Parent account {1} does not bolong to the company {2},Skladište {0}: Nadređeni račun {1} ne pripada tvrtki {2}
 DocType: BOM,Last Purchase Rate,Zadnja kupovna cijena
 DocType: Account,Asset,Asset
 DocType: Project Task,Task ID,Zadatak ID
 apps/erpnext/erpnext/public/js/setup_wizard.js +20,"e.g. ""MC""","na primjer ""MC"""
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +86,Stock cannot exist for Item {0} since has variants,Stock ne može postojati točkom {0} jer ima varijante
 ,Sales Person-wise Transaction Summary,Pregled prometa po prodavaču
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +104,Warehouse {0} does not exist,Skladište {0} ne postoji
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +112,Warehouse {0} does not exist,Skladište {0} ne postoji
 apps/erpnext/erpnext/hub_node/page/hub/register_in_hub.html +2,Register For ERPNext Hub,Registrirajte se za ERPNext Hub
 DocType: Monthly Distribution,Monthly Distribution Percentages,Mjesečni postotci distribucije
 apps/erpnext/erpnext/stock/doctype/batch/batch.py +16,The selected item cannot have Batch,Izabrani predmet ne može imati Hrpa
@@ -3115,10 +3206,11 @@
 apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +16,Setting this Address Template as default as there is no other default,"Postavljanje Ova adresa predloška kao zadano, jer nema drugog zadano"
 apps/erpnext/erpnext/accounts/doctype/account/account.py +113,"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 +76,Quality Management,Upravljanje kvalitetom
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +31,Item {0} has been disabled,Stavka {0} je onemogućen
 DocType: Payment Tool Detail,Against Voucher No,Protiv Voucher br
 apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +47,Please enter quantity for Item {0},Molimo unesite količinu za točku {0}
 DocType: Employee External Work History,Employee External Work History,Zaposlenik Vanjski Rad Povijest
-DocType: Tax Rule,Purchase,Kupiti
+DocType: Tax Rule,Purchase,Nabava
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Balance Qty,Bilanca kol
 DocType: Item Group,Parent Item Group,Nadređena grupa proizvoda
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} od {1}
@@ -3126,7 +3218,7 @@
 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},Red # {0}: vremenu sukobi s redom {1}
 DocType: Opportunity,Next Contact,Sljedeći Kontakt
-apps/erpnext/erpnext/config/accounts.py +245,Setup Gateway accounts.,Postava Gateway račune.
+apps/erpnext/erpnext/config/accounts.py +253,Setup Gateway accounts.,Postava 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 +40,Fixed Assets,Dugotrajne imovine
 ,Cash Flow,Protok novca
@@ -3140,7 +3232,7 @@
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Zadana aktivnost Troškovi postoji Vrsta djelatnosti - {0}
 DocType: Production Order,Planned Operating Cost,Planirani operativni trošak
 apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +121,New {0} Name,Novo {0} ime
-apps/erpnext/erpnext/controllers/recurring_document.py +132,Please find attached {0} #{1},U prilogu {0} # {1}
+apps/erpnext/erpnext/controllers/recurring_document.py +133,Please find attached {0} #{1},U prilogu {0} # {1}
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Bank Statement balance as per General Ledger,Banka Izjava stanje po glavnom knjigom
 DocType: Job Applicant,Applicant Name,Podnositelj zahtjeva Ime
 DocType: Authorization Rule,Customer / Item Name,Kupac / Stavka Ime
@@ -3156,19 +3248,18 @@
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +21,Please specify from/to range,Navedite od / do rasponu
 DocType: Serial No,Under AMC,Pod AMC
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +47,Item valuation rate is recalculated considering landed cost voucher amount,Stopa predmeta vrednovanja preračunava obzirom sletio troškova iznos vaučera
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +49,Customer &gt; Customer Group &gt; Territory,Kupac&gt; Korisnička Group&gt; Regija
 apps/erpnext/erpnext/config/selling.py +147,Default settings for selling transactions.,Zadane postavke za prodajne transakcije.
 DocType: BOM Replace Tool,Current BOM,Trenutni BOM
 apps/erpnext/erpnext/public/js/utils.js +39,Add Serial No,Dodaj serijski broj
 apps/erpnext/erpnext/config/support.py +43,Warranty,garancija
 DocType: Production Order,Warehouses,Skladišta
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Print and Stationary,Ispis i stacionarnih
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Print and Stationary,Ispis i stacionarnih
 apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +122,Group Node,Group Node
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +91,Update Finished Goods,Update gotovih proizvoda
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +92,Update Finished Goods,Update gotovih proizvoda
 DocType: Workstation,per hour,na sat
 apps/erpnext/erpnext/config/buying.py +7,Purchasing,Nabava
 DocType: Warehouse,Account for the warehouse (Perpetual Inventory) will be created under this Account.,Račun za skladište ( neprestani inventar) stvorit će se na temelju ovog računa .
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +95,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Skladište se ne može izbrisati dok postoje upisi u glavnu knjigu za ovo skladište.
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +103,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Skladište se ne može izbrisati dok postoje upisi u glavnu knjigu za ovo skladište.
 DocType: Company,Distribution,Distribucija
 apps/erpnext/erpnext/public/js/pos/pos.js +435,Amount Paid,Plaćeni iznos
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +91,Project Manager,Voditelj projekta
@@ -3198,7 +3289,7 @@
 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 Društvo
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +177,Cannot cancel because submitted Stock Entry {0} exists,"Ne može se otkazati, jer skladišni ulaz {0} postoji"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +179,Cannot cancel because submitted Stock Entry {0} exists,"Ne može se otkazati, jer skladišni ulaz {0} postoji"
 DocType: Purchase Invoice,In Words,Riječima
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Today is {0}'s birthday!,Danas je {0} 'rođendan!
 DocType: Production Planning Tool,Material Request For Warehouse,Zahtjev za robom za skladište
@@ -3206,14 +3297,16 @@
 DocType: Payment Request,payment_url,payment_url
 DocType: Project Task,View Task,Pregled zadataka
 apps/erpnext/erpnext/public/js/setup_wizard.js +40,Your financial year begins on,Vaša financijska godina počinje
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +46,Please enter Purchase Receipts,Unesite Kupnja primici
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +46,Please enter Purchase Receipts,Unesite primke
 DocType: Sales Invoice,Get Advances Received,Kreiraj avansno primanje
 DocType: Email Digest,Add/Remove Recipients,Dodaj / ukloni primatelja
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +427,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 +133,Join,Pridružiti
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +19,Shortage Qty,Nedostatak Kom
-apps/erpnext/erpnext/stock/doctype/item/item.py +564,Item variant {0} exists with same attributes,Inačica Stavka {0} postoji s istim atributima
+apps/erpnext/erpnext/stock/doctype/item/item.py +569,Item variant {0} exists with same attributes,Inačica Stavka {0} postoji s istim atributima
 DocType: Salary Slip,Salary Slip,Plaća proklizavanja
+DocType: Pricing Rule,Margin Rate or Amount,Margina brzine ili količine
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +48,'To Date' is required,'Do datuma ' je potrebno
 DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Izradi pakiranje gaćice za pakete biti isporučena. Koristi se za obavijesti paket broj, sadržaj paketa i njegovu težinu."
 DocType: Sales Invoice Item,Sales Order Item,Naručeni proizvod - prodaja
@@ -3223,7 +3316,7 @@
 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: Employee Education,Employee Education,Obrazovanje zaposlenika
-apps/erpnext/erpnext/public/js/controllers/transaction.js +782,It is needed to fetch Item Details.,To je potrebno kako bi dohvatili Stavka Pojedinosti.
+apps/erpnext/erpnext/public/js/controllers/transaction.js +793,It is needed to fetch Item Details.,To je potrebno kako bi dohvatili Stavka Pojedinosti.
 DocType: Salary Slip,Net Pay,Neto plaća
 DocType: Account,Account,Račun
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} has already been received,Serijski Ne {0} već je primila
@@ -3231,14 +3324,13 @@
 DocType: Customer,Sales Team Details,Detalji prodnog tima
 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 +177,Invalid {0},Pogrešna {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +178,Invalid {0},Pogrešna {0}
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +48,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/doctype/naming_series/naming_series.py +187,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Molimo postavite Imenovanje serija za {0} preko Postavljanje&gt; Postavke&gt; imenujući serije
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +22,Department Stores,Robne kuće
 apps/erpnext/erpnext/controllers/stock_controller.py +72,No accounting entries for the following warehouses,Nema računovodstvenih unosa za ova skladišta
-apps/erpnext/erpnext/projects/doctype/project/project.js +22,Save the document first.,Spremite dokument prvi.
+apps/erpnext/erpnext/projects/doctype/project/project.js +73,Save the document first.,Spremite dokument prvi.
 DocType: Account,Chargeable,Naplativ
 DocType: Company,Change Abbreviation,Promijeni naziv
 DocType: Expense Claim Detail,Expense Date,Rashodi Datum
@@ -3256,14 +3348,15 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +89,Business Development Manager,Voditelj razvoja poslovanja
 DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Održavanje Posjetite Namjena
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +15,Period,Razdoblje
-,General Ledger,Glavna knjiga
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +12,General Ledger,Glavna knjiga
 apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Pogledaj vodi
 DocType: Item Attribute Value,Attribute Value,Vrijednost atributa
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +65,"Email id must be unique, already exists for {0}","Email ID mora biti jedinstven , već postoji za {0}"
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +67,"Email id must be unique, already exists for {0}","Email ID mora biti jedinstven , već postoji za {0}"
 ,Itemwise Recommended Reorder Level,Itemwise - preporučena razina ponovne narudžbe
 apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +268,Please select {0} first,Odaberite {0} Prvi
 DocType: Features Setup,To get Item Group in details table,Da biste dobili predmeta Group u tablici pojedinosti
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +114,Batch {0} of Item {1} has expired.,Hrpa {0} od {1} Stavka je istekla.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Please set a default Holiday List for Employee {0} or Company {0},Postavite zadani popis za odmor za zaposlenika {0} ili poduzeću {0}
 DocType: Sales Invoice,Commission,provizija
 DocType: Address Template,"<h4>Default Template</h4>
 <p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p>
@@ -3293,25 +3386,25 @@
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +107,This Month's Summary,Ovomjesečnom Sažetak
 DocType: Quality Inspection Reading,Quality Inspection Reading,Inspekcija kvalitete - čitanje
 apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,` Freeze Dionice starije od ` bi trebao biti manji od % d dana .
-DocType: Tax Rule,Purchase Tax Template,Porez na predložak
+DocType: Tax Rule,Purchase Tax Template,Predložak poreza pri nabavi
 ,Project wise Stock Tracking,Projekt mudar Stock Praćenje
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +153,Maintenance Schedule {0} exists against {0},Raspored održavanja {0} postoji od {0}
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +157,Maintenance Schedule {0} exists against {0},Raspored održavanja {0} postoji od {0}
 DocType: Stock Entry Detail,Actual Qty (at source/target),Stvarni Kol (na izvoru / ciljne)
 DocType: Item Customer Detail,Ref Code,Ref. Šifra
 apps/erpnext/erpnext/config/hr.py +12,Employee records.,Evidencija zaposlenih.
 DocType: Payment Gateway,Payment Gateway,Payment Gateway
 DocType: HR Settings,Payroll Settings,Postavke plaće
-apps/erpnext/erpnext/config/accounts.py +135,Match non-linked Invoices and Payments.,Klađenje na ne-povezane faktura i plaćanja.
+apps/erpnext/erpnext/config/accounts.py +143,Match non-linked Invoices and Payments.,Klađenje na ne-povezane faktura i plaćanja.
 apps/erpnext/erpnext/templates/pages/cart.html +22,Place Order,Naručiti
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +25,Root cannot have a parent cost center,Korijen ne mogu imati središte troškova roditelj
 apps/erpnext/erpnext/public/js/stock_analytics.js +59,Select Brand...,Odaberite brand ...
 DocType: Sales Invoice,C-Form Applicable,Primjenjivi C-obrazac
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +351,Operation Time must be greater than 0 for Operation {0},Operacija vrijeme mora biti veći od 0 za rad {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +353,Operation Time must be greater than 0 for Operation {0},Operacija vrijeme mora biti veći od 0 za rad {0}
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +104,Warehouse is mandatory,Skladište je obavezno
 DocType: Supplier,Address and Contacts,Adresa i kontakti
 DocType: UOM Conversion Detail,UOM Conversion Detail,UOM pretvorbe Detalj
 apps/erpnext/erpnext/public/js/setup_wizard.js +144,Keep it web friendly 900px (w) by 100px (h),Postavite dimenzije prilagođene web-u 900px X 100px
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +340,Production Order cannot be raised against a Item Template,Proizvodnja Red ne može biti podignuta protiv predložak točka
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +342,Production Order cannot be raised against a Item Template,Proizvodnja Red ne može biti podignuta protiv predložak točka
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +44,Charges are updated in Purchase Receipt against each item,Optužbe su ažurirani u KUPNJE protiv svake stavke
 DocType: Payment Tool,Get Outstanding Vouchers,Dobiti izvrsne Vaučeri
 DocType: Warranty Claim,Resolved By,Riješen Do
@@ -3329,7 +3422,7 @@
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +41,Remove item if charges is not applicable to that item,Uklanjanje stavke ako troškovi se ne odnosi na tu stavku
 DocType: SMS Settings,Eg. smsgateway.com/api/send_sms.cgi,Npr.. smsgateway.com / api / send_sms.cgi
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Transaction currency must be same as Payment Gateway currency,Transakcija valute mora biti isti kao i Payment Gateway valute
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +633,Receive,Primite
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +636,Receive,Primite
 DocType: Maintenance Visit,Fully Completed,Potpuno Završeni
 apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Napravljeno
 DocType: Employee,Educational Qualification,Obrazovne kvalifikacije
@@ -3337,14 +3430,14 @@
 DocType: Purchase Invoice,Submit on creation,Pošalji na stvaranje
 DocType: Employee Leave Approver,Employee Leave Approver,Zaposlenik dopust Odobritelj
 apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +166,{0} has been successfully added to our Newsletter list.,{0} je uspješno dodana na popis Newsletter.
-apps/erpnext/erpnext/stock/doctype/item/item.py +420,Row {0}: An Reorder entry already exists for this warehouse {1},Red {0}: Ulazak redoslijeda već postoji za to skladište {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +425,Row {0}: An Reorder entry already exists for this warehouse {1},Red {0}: Ulazak redoslijeda već postoji za to skladište {1}
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +65,"Cannot declare as lost, because Quotation has been made.","Ne može se proglasiti izgubljenim, jer je ponuda napravljena."
-DocType: Purchase Taxes and Charges Template,Purchase Master Manager,Kupnja Master Manager
+DocType: Purchase Taxes and Charges Template,Purchase Master Manager,Upravitelj predloška nabave
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +424,Production Order {0} must be submitted,Proizvodnja Red {0} mora biti podnesen
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +137,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/support/doctype/maintenance_schedule/maintenance_schedule.py +141,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/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: Purchase Receipt Item,Prevdoc DocType,Prevdoc DOCTYPE
-apps/erpnext/erpnext/stock/doctype/item/item.js +187,Add / Edit Prices,Dodaj / Uredi cijene
+apps/erpnext/erpnext/stock/doctype/item/item.js +174,Add / Edit Prices,Dodaj / Uredi cijene
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +53,Chart of Cost Centers,Grafikon troškovnih centara
 ,Requested Items To Be Ordered,Traženi Proizvodi se mogu naručiti
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +313,My Orders,Moje narudžbe
@@ -3365,10 +3458,10 @@
 apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +25,Please enter valid mobile nos,Unesite valjane mobilne br
 DocType: Budget Detail,Budget Detail,Detalji proračuna
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Unesite poruku prije slanja
-apps/erpnext/erpnext/config/accounts.py +250,Point-of-Sale Profile,Point-of-prodaju Profil
+apps/erpnext/erpnext/config/accounts.py +258,Point-of-Sale Profile,Point-of-prodaju Profil
 apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +68,Please Update SMS Settings,Obnovite SMS Settings
 apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +37,Time Log {0} already billed,Vrijeme Prijavite {0} već naplaćeno
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +176,Unsecured Loans,unsecured krediti
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +179,Unsecured Loans,unsecured krediti
 DocType: Cost Center,Cost Center Name,Troška Name
 DocType: Maintenance Schedule Detail,Scheduled Date,Planirano Datum
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +63,Total Paid Amt,Cjelokupni iznos Amt
@@ -3380,11 +3473,12 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +272,You cannot credit and debit same account at the same time,Ne možete istovremeno kreditirati i debitirati isti račun
 DocType: Naming Series,Help HTML,HTML pomoć
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +50,Total weightage assigned should be 100%. It is {0},Ukupno bi trebalo biti dodijeljena weightage 100 % . To je {0}
-apps/erpnext/erpnext/controllers/status_updater.py +141,Allowance for over-{0} crossed for Item {1},Dodatak za prekomjerno {0} prešao za točku {1}
+apps/erpnext/erpnext/controllers/status_updater.py +143,Allowance for over-{0} crossed for Item {1},Dodatak za prekomjerno {0} prešao za točku {1}
 DocType: Address,Name of person or organization that this address belongs to.,Ime osobe ili organizacije kojoj ova adresa pripada.
 apps/erpnext/erpnext/public/js/setup_wizard.js +234,Your Suppliers,Vaši dobavljači
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +53,Cannot set as Lost as Sales Order is made.,Ne mogu se postaviti kao izgubljen kao prodajnog naloga je napravio .
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +65,Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,Još Struktura plaća {0} je aktivna djelatnika {1}. Molimo provjerite njegov status 'Neaktivan' za nastavak.
+apps/erpnext/erpnext/templates/includes/rfq/rfq_macros.html +16,Supplier Part No,Dobavljač Dio Ne
 DocType: Purchase Invoice,Contact,Kontakt
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +9,Received From,Primljeno od
 DocType: Features Setup,Exports,Izvoz
@@ -3393,12 +3487,12 @@
 DocType: Employee,Date of Issue,Datum izdavanja
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +15,{0}: From {0} for {1},{0}: Od {0} od {1}
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +150,Row #{0}: Set Supplier for item {1},Red # {0}: Postavite dobavljač za stavke {1}
-apps/erpnext/erpnext/stock/doctype/item/item.py +114,Website Image {0} attached to Item {1} cannot be found,Web stranica slike {0} prilogu točki {1} Ne mogu naći
+apps/erpnext/erpnext/stock/doctype/item/item.py +119,Website Image {0} attached to Item {1} cannot be found,Web stranica slike {0} prilogu točki {1} Ne mogu naći
 DocType: Issue,Content Type,Vrsta sadržaja
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,računalo
 DocType: Item,List this Item in multiple groups on the website.,Prikaži ovu stavku u više grupa na web stranici.
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +296,Please check Multi Currency option to allow accounts with other currency,Molimo provjerite više valuta mogućnost dopustiti račune s druge valute
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +65,Item: {0} does not exist in the system,Stavka: {0} ne postoji u sustavu
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +74,Item: {0} does not exist in the system,Stavka: {0} ne postoji u sustavu
 apps/erpnext/erpnext/accounts/doctype/account/account.py +105,You are not authorized to set Frozen value,Niste ovlašteni za postavljanje zamrznute vrijednosti
 DocType: Payment Reconciliation,Get Unreconciled Entries,Kreiraj neusklađene ulaze
 DocType: Payment Reconciliation,From Invoice Date,Iz dostavnice Datum
@@ -3407,7 +3501,7 @@
 DocType: Delivery Note,To Warehouse,Za skladište
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +45,Account {0} has been entered more than once for fiscal year {1},Račun {0} je unešen više od jednom za fiskalnu godinu {1}
 ,Average Commission Rate,Prosječna provizija
-apps/erpnext/erpnext/stock/doctype/item/item.py +351,'Has Serial No' can not be 'Yes' for non-stock item,'Ima serijski broj' ne može biti 'Da' za neskladišne proizvode
+apps/erpnext/erpnext/stock/doctype/item/item.py +356,'Has Serial No' can not be 'Yes' for non-stock item,'Ima serijski broj' ne može biti 'Da' za neskladišne proizvode
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +34,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,Pravila cijena - pomoć
 DocType: Purchase Taxes and Charges,Account Head,Zaglavlje računa
@@ -3420,7 +3514,7 @@
 DocType: Item,Customer Code,Kupac Šifra
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +219,Birthday Reminder for {0},Rođendan Podsjetnik za {0}
 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 +305,Debit To account must be a Balance Sheet account,Zaduženja računa mora biti bilanca račun
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +306,Debit To account must be a Balance Sheet account,Zaduženja računa mora biti bilanca račun
 DocType: Buying Settings,Naming Series,Imenovanje serije
 DocType: Leave Block List,Leave Block List Name,Naziv popisa neodobrenih odsustava
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,dionicama u vrijednosti
@@ -3434,15 +3528,15 @@
 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
 DocType: Authorization Rule,Based On,Na temelju
 DocType: Sales Order Item,Ordered Qty,Naručena kol
-apps/erpnext/erpnext/stock/doctype/item/item.py +576,Item {0} is disabled,Stavka {0} je onemogućen
+apps/erpnext/erpnext/stock/doctype/item/item.py +585,Item {0} is disabled,Stavka {0} je onemogućen
 DocType: Stock Settings,Stock Frozen Upto,Kataloški Frozen Upto
-apps/erpnext/erpnext/controllers/recurring_document.py +168,Period From and Period To dates mandatory for recurring {0},Razdoblje od razdoblja do datuma obvezna za ponavljajućih {0}
+apps/erpnext/erpnext/controllers/recurring_document.py +169,Period From and Period To dates mandatory for recurring {0},Razdoblje od razdoblja do datuma obvezna za ponavljajućih {0}
 apps/erpnext/erpnext/config/projects.py +18,Project activity / task.,Projekt aktivnost / zadatak.
 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 +41,"Buying must be checked, if Applicable For is selected as {0}","Kupnja treba biti provjerena, ako je primjenjivo za odabrano kao {0}"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Buying must be checked, if Applicable For is selected as {0}","Nabava mora biti provjerena, ako je primjenjivo za odabrano kao {0}"
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Popust mora biti manji od 100
 DocType: Purchase Invoice,Write Off Amount (Company Currency),Otpis iznos (Društvo valuta)
-apps/erpnext/erpnext/stock/doctype/item/item.py +412,Row #{0}: Please set reorder quantity,Red # {0}: Molimo postavite naručivanja količinu
+apps/erpnext/erpnext/stock/doctype/item/item.py +417,Row #{0}: Please set reorder quantity,Red # {0}: Molimo postavite naručivanja količinu
 DocType: Landed Cost Voucher,Landed Cost Voucher,Nalog zavisnog troška
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +55,Please set {0},Molimo postavite {0}
 DocType: Purchase Invoice,Repeat on Day of Month,Ponovite na dan u mjesecu
@@ -3462,8 +3556,9 @@
 apps/erpnext/erpnext/crm/doctype/lead/lead.py +37,Campaign Name is required,Potreban je naziv kampanje
 DocType: Maintenance Visit,Maintenance Date,Datum održavanje
 DocType: Purchase Receipt Item,Rejected Serial No,Odbijen Serijski br
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +73,Year start date or end date is overlapping with {0}. To avoid please set company,Godina datum početka ili završetka je preklapanje s {0}. Da bi se izbjegla postavite tvrtku
 apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +40,New Newsletter,Novi bilten
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +144,Start date should be less than end date for Item {0},Početak bi trebao biti manji od krajnjeg datuma za točke {0}
+apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +148,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 Serija je postavljena i serijski broj ne spominje u prometu, a zatim automatsko serijski broj će biti izrađen na temelju ove serije. Ako ste uvijek žele eksplicitno spomenuti serijski brojevi za tu stavku. ostavite praznim."
@@ -3475,11 +3570,11 @@
 ,Sales Analytics,Prodajna analitika
 DocType: Manufacturing Settings,Manufacturing Settings,Postavke proizvodnje
 apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Postavljanje e-poštu
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +91,Please enter default currency in Company Master,Unesite zadanu valutu u tvrtki Master
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +92,Please enter default currency in Company Master,Unesite zadanu valutu u tvrtki Master
 DocType: Stock Entry Detail,Stock Entry Detail,Detalji međuskladišnice
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +101,Daily Reminders,Dnevne Podsjetnici
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +82,Tax Rule Conflicts with {0},Porezni Pravilo Sukobi s {0}
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +206,New Account Name,Naziv novog računa
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +209,New Account Name,Naziv novog računa
 DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Sirovine Isporuka Troškovi
 DocType: Selling Settings,Settings for Selling Module,Postavke za prodaju modula
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +73,Customer Service,Služba za korisnike
@@ -3489,11 +3584,12 @@
 apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Ponuda kandidata za 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 +81,Total allocated leaves are more than days in the period,Ukupno dodijeljeni Listovi su više od dana u razdoblju
+DocType: Pricing Rule,Percentage,Postotak
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +72,Item {0} must be a stock Item,Proizvod {0} mora biti skladišni
 DocType: Manufacturing Settings,Default Work In Progress Warehouse,Zadana rad u tijeku Skladište
-apps/erpnext/erpnext/config/accounts.py +225,Default settings for accounting transactions.,Zadane postavke za računovodstvene poslove.
+apps/erpnext/erpnext/config/accounts.py +233,Default settings for accounting transactions.,Zadane postavke za računovodstvene poslove.
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +59,Expected Date cannot be before Material Request Date,Očekivani datum ne može biti prije Materijal Zahtjev Datum
-apps/erpnext/erpnext/stock/get_item_details.py +132,Item {0} must be a Sales Item,Stavka {0} mora bitiProdaja artikla
+apps/erpnext/erpnext/stock/get_item_details.py +131,Item {0} must be a Sales Item,Stavka {0} mora bitiProdaja artikla
 DocType: Naming Series,Update Series Number,Update serije Broj
 DocType: Account,Equity,pravičnost
 DocType: Sales Order,Printing Details,Ispis Detalji
@@ -3501,11 +3597,12 @@
 DocType: Sales Order Item,Produced Quantity,Proizvedena količina
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Engineer,inženjer
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Traži Sub skupštine
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +385,Item Code required at Row No {0},Kod proizvoda je potreban u redu broj {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +378,Item Code required at Row No {0},Kod proizvoda je potreban u redu broj {0}
 DocType: Sales Partner,Partner Type,Tip partnera
 DocType: Purchase Taxes and Charges,Actual,Stvaran
 DocType: Authorization Rule,Customerwise Discount,Customerwise Popust
 DocType: Purchase Invoice,Against Expense Account,Protiv Rashodi račun
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +36,"Go to the appropriate group (usually Source of Funds &gt; Current Liabilities &gt; Taxes and Duties and create a new Account (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.",Idi u odgovarajuću grupu (obično izvor sredstava&gt; kratkoročne obveze&gt; poreza i pristojbi te stvoriti novi korisnički račun (klikom na Dodaj Child) tipa &quot;porez&quot; i ne spominju stope poreza.
 DocType: Production Order,Production Order,Proizvodni nalog
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +248,Installation Note {0} has already been submitted,Napomena instalacije {0} je već potvrđena
 DocType: Quotation Item,Against Docname,Protiv Docname
@@ -3524,18 +3621,19 @@
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +45,Retail & Wholesale,Trgovina na veliko i
 DocType: Issue,First Responded On,Prvo Odgovorili Na
 DocType: Website Item Group,Cross Listing of Item in multiple groups,Križ Oglas pošiljke u više grupa
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +49,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/fiscal_year/fiscal_year.py +81,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/payment_reconciliation/payment_reconciliation.py +115,Successfully Reconciled,Uspješno Pomirio
 DocType: Production Order,Planned End Date,Planirani datum završetka
 apps/erpnext/erpnext/config/stock.py +180,Where items are stored.,Gdje predmeti su pohranjeni.
 DocType: Tax Rule,Validity,Valjanost
+DocType: Request for Quotation,Supplier Detail,Dobavljač Detalj
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +19,Invoiced Amount,Dostavljeni iznos
 DocType: Attendance,Attendance,Pohađanje
 apps/erpnext/erpnext/config/projects.py +55,Reports,Izvješća
 DocType: BOM,Materials,Materijali
 DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Ako nije označeno, popis će biti dodan u svakom odjela gdje se mora primjenjivati."
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508,Posting date and posting time is mandatory,Datum knjiženja i knjiženje vrijeme je obvezna
-apps/erpnext/erpnext/config/buying.py +71,Tax template for buying transactions.,Porezna Predložak za kupnju transakcije .
+apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Porezna Predložak za kupnju transakcije .
 ,Item Prices,Cijene proizvoda
 DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,U riječi će biti vidljiv nakon što spremite narudžbenice.
 DocType: Period Closing Voucher,Period Closing Voucher,Razdoblje Zatvaranje bon
@@ -3545,10 +3643,10 @@
 DocType: Purchase Taxes and Charges,On Net Total,VPC
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +159,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/accounts/doctype/payment_tool/payment_tool.py +99,No permission to use Payment Tool,Nemate dopuštenje za korištenje platnih alata
-apps/erpnext/erpnext/controllers/recurring_document.py +204,'Notification Email Addresses' not specified for recurring %s,'Obavijest E-mail adrese' nije navedena za ponavljajuće %s
+apps/erpnext/erpnext/controllers/recurring_document.py +214,'Notification Email Addresses' not specified for recurring %s,'Obavijest E-mail adrese' nije navedena za ponavljajuće %s
 apps/erpnext/erpnext/accounts/doctype/account/account.py +123,Currency can not be changed after making entries using some other currency,Valuta se ne može mijenjati nakon što unose pomoću neke druge valute
 DocType: Company,Round Off Account,Zaokružiti račun
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +84,Administrative Expenses,Administrativni troškovi
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +87,Administrative Expenses,Administrativni troškovi
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,savjetodavni
 DocType: Customer Group,Parent Customer Group,Nadređena grupa kupaca
 apps/erpnext/erpnext/public/js/pos/pos.js +455,Change,Promjena
@@ -3556,6 +3654,7 @@
 DocType: Appraisal Goal,Score Earned,Ocjena Zarađeni
 apps/erpnext/erpnext/public/js/setup_wizard.js +18,"e.g. ""My Company LLC""","na primjer ""Moja tvrtka LLC"""
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +173,Notice Period,Otkaznog roka
+DocType: Asset Category,Asset Category Name,Imovina Kategorija Naziv
 DocType: Bank Reconciliation Detail,Voucher ID,Bon ID
 apps/erpnext/erpnext/setup/doctype/territory/territory.js +14,This is a root territory and cannot be edited.,Ovo je glavni teritorij i ne može se mijenjati.
 DocType: Packing Slip,Gross Weight UOM,Bruto težina UOM
@@ -3567,13 +3666,13 @@
 DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Količina proizvoda dobivena nakon proizvodnje / pakiranja od navedene količine sirovina
 DocType: Payment Reconciliation,Receivable / Payable Account,Potraživanja / Plaća račun
 DocType: Delivery Note Item,Against Sales Order Item,Protiv prodaje reda točkom
-apps/erpnext/erpnext/stock/doctype/item/item.py +559,Please specify Attribute Value for attribute {0},Navedite značajke vrijednost za atribut {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +564,Please specify Attribute Value for attribute {0},Navedite značajke vrijednost za atribut {0}
 DocType: Item,Default Warehouse,Glavno skladište
 DocType: Task,Actual End Date (via Time Logs),Stvarni datum završetka (preko Vrijeme Trupci)
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +37,Budget cannot be assigned against Group Account {0},Proračun se ne može dodijeliti protiv grupe nalog {0}
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +23,Please enter parent cost center,Unesite roditelj troška
 DocType: Delivery Note,Print Without Amount,Ispis Bez visini
-apps/erpnext/erpnext/controllers/buying_controller.py +60,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,Porezna Kategorija ne može biti ' Procjena ' ili ' Procjena i Total ' kao i svi proizvodi bez zaliha predmeta
+apps/erpnext/erpnext/controllers/buying_controller.py +61,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,Porezna Kategorija ne može biti ' Procjena ' ili ' Procjena i Total ' kao i svi proizvodi bez zaliha predmeta
 DocType: Issue,Support Team,Tim za podršku
 DocType: Appraisal,Total Score (Out of 5),Ukupna ocjena (od 5)
 DocType: Batch,Batch,Serija
@@ -3587,7 +3686,7 @@
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Sales Person,Prodajna osoba
 DocType: Sales Invoice,Cold Calling,Hladno pozivanje
 DocType: SMS Parameter,SMS Parameter,SMS parametra
-apps/erpnext/erpnext/config/accounts.py +184,Budget and Cost Center,Proračun i Centar Cijena
+apps/erpnext/erpnext/config/accounts.py +192,Budget and Cost Center,Proračun i Centar Cijena
 DocType: Maintenance Schedule Item,Half Yearly,Pola godišnji
 DocType: Lead,Blog Subscriber,Blog pretplatnik
 apps/erpnext/erpnext/config/setup.py +88,Create rules to restrict transactions based on values.,Napravi pravila za ograničavanje prometa na temelju vrijednosti.
@@ -3615,12 +3714,12 @@
 DocType: Attendance,Employee Name,Ime zaposlenika
 DocType: Sales Invoice,Rounded Total (Company Currency),Zaobljeni Ukupno (Društvo valuta)
 apps/erpnext/erpnext/accounts/doctype/account/account.py +95,Cannot covert to Group because Account Type is selected.,Ne može se tajno u grupu jer je izabrana vrsta računa.
-DocType: Purchase Common,Purchase Common,Kupnja Zajednička
+DocType: Purchase Common,Purchase Common,Zajednička nabava
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +93,{0} {1} has been modified. Please refresh.,{0} {1} je izmijenjen. Osvježi stranicu.
 DocType: Leave Block List,Stop users from making Leave Applications on following days.,Prestani korisnike od izrade ostaviti aplikacija na sljedećim danima.
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +165,Supplier Quotation {0} created,Dobavljač Navod {0} stvorio
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +166,Employee Benefits,Primanja zaposlenih
 DocType: Sales Invoice,Is POS,Je POS
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +46,Item Code &gt; Item Group &gt; Brand,Stavka Šifra&gt; Stavka Group&gt; Brand
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +230,Packed quantity must equal quantity for Item {0} in row {1},Pakirana količina mora biti jednaka količini za proizvod {0} u redku {1}
 DocType: Production Order,Manufactured Qty,Proizvedena količina
 DocType: Purchase Receipt Item,Accepted Quantity,Prihvaćena količina
@@ -3628,7 +3727,7 @@
 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 +492,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Redak Ne {0}: Iznos ne može biti veća od visine u tijeku protiv Rashodi Zahtjeva {1}. U tijeku Iznos je {2}
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.py +40,{0} subscribers added,Dodao {0} pretplatnika
+apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.py +42,{0} subscribers added,Dodao {0} pretplatnika
 DocType: Maintenance Schedule,Schedule,Raspored
 DocType: Cost Center,"Define Budget for this Cost Center. To set budget action, see ""Company List""","Odredite proračun za ovu troška. Za postavljanje proračuna akcije, pogledajte &quot;Lista poduzeća&quot;"
 DocType: Account,Parent Account,Nadređeni račun
@@ -3644,7 +3743,7 @@
 DocType: Employee,Education,Obrazovanje
 DocType: Selling Settings,Campaign Naming By,Imenovanje kampanja po
 DocType: Employee,Current Address Is,Trenutni Adresa je
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +219,"Optional. Sets company's default currency, if not specified.","Izborni. Postavlja tvrtke zadanu valutu, ako nije navedeno."
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +222,"Optional. Sets company's default currency, if not specified.","Izborni. Postavlja tvrtke zadanu valutu, ako nije navedeno."
 DocType: Address,Office,Ured
 apps/erpnext/erpnext/config/accounts.py +50,Accounting journal entries.,Knjigovodstvene temeljnice
 DocType: Delivery Note Item,Available Qty at From Warehouse,Dostupno Količina u iz skladišta
@@ -3655,10 +3754,11 @@
 DocType: Account,Stock,Lager
 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 predmet je varijanta drugom stavku zatim opis, slika, cijena, porezi itd će biti postavljena od predloška, osim ako je izričito navedeno"
-DocType: Serial No,Purchase / Manufacture Details,Kupnja / Proizvodnja Detalji
+DocType: Serial No,Purchase / Manufacture Details,Detalji nabave/proizvodnje
 apps/erpnext/erpnext/config/stock.py +310,Batch Inventory,Hrpa Inventar
 DocType: Employee,Contract End Date,Ugovor Datum završetka
 DocType: Sales Order,Track this Sales Order against any Project,Prati ovu prodajni nalog protiv bilo Projekta
+DocType: Sales Invoice Item,Discount and Margin,Popusti i margina
 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
 DocType: Deduction Type,Deduction Type,Tip odbitka
 DocType: Attendance,Half Day,Pola dana
@@ -3679,7 +3779,7 @@
 DocType: Hub Settings,Hub Settings,Hub Postavke
 DocType: Project,Gross Margin %,Bruto marža %
 DocType: BOM,With Operations,Uz operacije
-apps/erpnext/erpnext/accounts/party.py +232,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Računovodstvenih unosa već su napravljene u valuti {0} za poduzeće {1}. Odaberite potraživanja ili dugovanja račun s valutom {0}.
+apps/erpnext/erpnext/accounts/party.py +234,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Računovodstvenih unosa već su napravljene u valuti {0} za poduzeće {1}. Odaberite potraživanja ili dugovanja račun s valutom {0}.
 ,Monthly Salary Register,Mjesečna plaća Registracija
 DocType: Warranty Claim,If different than customer address,Ako se razlikuje od kupaca adresu
 DocType: BOM Operation,BOM Operation,BOM operacija
@@ -3687,22 +3787,23 @@
 apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +33,Please enter Payment Amount in atleast one row,Unesite iznos otplate u atleast jednom redu
 DocType: POS Profile,POS Profile,POS profil
 DocType: Payment Gateway Account,Payment URL Message,Plaćanje URL poruka
-apps/erpnext/erpnext/config/accounts.py +204,"Seasonality for setting budgets, targets etc.","Sezonska za postavljanje proračuna, ciljevi itd"
+apps/erpnext/erpnext/config/accounts.py +212,"Seasonality for setting budgets, targets etc.","Sezonska za postavljanje proračuna, ciljevi itd"
 apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +242,Row {0}: Payment Amount cannot be greater than Outstanding Amount,Red {0}: Plaćanje Iznos ne može biti veći od preostali iznos
 apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +69,Total Unpaid,Ukupno Neplaćeni
 apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +32,Time Log is not billable,Vrijeme Log nije naplatnih
-apps/erpnext/erpnext/stock/get_item_details.py +135,"Item {0} is a template, please select one of its variants","Stavka {0} je predložak, odaberite jednu od njegovih varijanti"
-apps/erpnext/erpnext/public/js/setup_wizard.js +178,Purchaser,Kupac
+apps/erpnext/erpnext/stock/get_item_details.py +134,"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,imovina Kategorija
+apps/erpnext/erpnext/public/js/setup_wizard.js +178,Purchaser,Dobavljač
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +81,Net pay cannot be negative,Neto plaća ne može biti negativna
 apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +109,Please enter the Against Vouchers manually,Unesite protiv vaučera ručno
 DocType: SMS Settings,Static Parameters,Statički parametri
 DocType: Purchase Order,Advance Paid,Unaprijed plaćeni
 DocType: Item,Item Tax,Porez proizvoda
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +636,Material to Supplier,Materijal za dobavljača
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +639,Material to Supplier,Materijal za dobavljača
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +179,Excise Invoice,Trošarine Račun
 DocType: Expense Claim,Employees Email Id,Zaposlenici Email ID
 DocType: Employee Attendance Tool,Marked Attendance,Označena posjećenost
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +159,Current Liabilities,Kratkoročne obveze
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +162,Current Liabilities,Kratkoročne obveze
 apps/erpnext/erpnext/config/crm.py +127,Send mass SMS to your contacts,Pošalji grupne SMS poruke svojim kontaktima
 DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Razmislite poreza ili pristojbi za
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +59,Actual Qty is mandatory,Stvarni Količina je obavezno
@@ -3723,17 +3824,16 @@
 DocType: Item Attribute,Numeric Values,Brojčane vrijednosti
 apps/erpnext/erpnext/public/js/setup_wizard.js +149,Attach Logo,Pričvrstite Logo
 DocType: Customer,Commission Rate,Komisija Stopa
-apps/erpnext/erpnext/stock/doctype/item/item.js +223,Make Variant,Napravite varijanta
+apps/erpnext/erpnext/stock/doctype/item/item.js +210,Make Variant,Napravite varijanta
 apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Blok ostaviti aplikacija odjelu.
 apps/erpnext/erpnext/config/stock.py +201,Analytics,Analitika
 apps/erpnext/erpnext/templates/pages/cart.html +51,Cart is Empty,Košarica je prazna
 DocType: Production Order,Actual Operating Cost,Stvarni operativni trošak
-apps/erpnext/erpnext/utilities/doctype/address/address.py +151,No default Address Template found. Please create a new one from Setup &gt; Printing and Branding &gt; Address Template.,Ne zadana adresa predloška pronađen. Molimo stvoriti novi iz Setup&gt; Tisak i Branding&gt; Address predložak.
 apps/erpnext/erpnext/accounts/doctype/account/account.py +80,Root cannot be edited.,Korijen ne može se mijenjati .
 apps/erpnext/erpnext/accounts/utils.py +197,Allocated amount can not greater than unadusted amount,Dodijeljeni iznos ne može veći od iznosa unadusted
 DocType: Manufacturing Settings,Allow Production on Holidays,Dopustite proizvodnje na odmor
 DocType: Sales Order,Customer's Purchase Order Date,Kupca narudžbenice Datum
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +183,Capital Stock,Kapital
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +186,Capital Stock,Kapital
 DocType: Packing Slip,Package Weight Details,Težina paketa - detalji
 DocType: Payment Gateway Account,Payment Gateway Account,Payment Gateway račun
 DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Nakon završetka plaćanja preusmjeriti korisnika na odabranu stranicu.
@@ -3742,20 +3842,21 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +94,Designer,Imenovatelj
 apps/erpnext/erpnext/config/selling.py +157,Terms and Conditions Template,Uvjeti i odredbe - šprance
 DocType: Serial No,Delivery Details,Detalji isporuke
+DocType: Asset,Current Value (After Depreciation),Trenutna vrijednost (nakon amortizacije)
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +380,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}
-,Item-wise Purchase Register,Stavka-mudar Kupnja Registracija
+,Item-wise Purchase Register,Popis nabave po stavkama
 DocType: Batch,Expiry Date,Datum isteka
-apps/erpnext/erpnext/stock/doctype/item/item.py +408,"To set reorder level, item must be a Purchase Item or Manufacturing Item",Za postavljanje razine naručivanja točka mora biti Kupnja predmeta ili proizvodnja predmeta
+apps/erpnext/erpnext/stock/doctype/item/item.py +413,"To set reorder level, item must be a Purchase Item or Manufacturing Item","Za postavljanje razine automatske narudžbe, stavka mora biti odobrena za nabavu ili proizvodnju"
 ,Supplier Addresses and Contacts,Supplier Adrese i kontakti
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +268,Please select Category first,Molimo odaberite kategoriju prvi
 apps/erpnext/erpnext/config/projects.py +13,Project master.,Projekt majstor.
 DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Ne pokazati nikakav simbol kao $ iza valute.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +409, (Half Day),(Pola dana)
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +407, (Half Day),(Pola dana)
 DocType: Supplier,Credit Days,Kreditne Dani
 DocType: Leave Type,Is Carry Forward,Je Carry Naprijed
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +599,Get Items from BOM,Kreiraj proizvode od sastavnica (BOM)
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +602,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/manufacturing/doctype/production_planning_tool/production_planning_tool.py +126,Please enter Sales Orders in the above table,Unesite prodajni nalozi u gornjoj tablici
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +129,Please enter Sales Orders in the above table,Unesite prodajni nalozi u gornjoj tablici
 apps/erpnext/erpnext/config/manufacturing.py +33,Bill of Materials,Bill of Materials
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +76,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Red {0}: Stranka Tip i stranka je potrebno za potraživanja / obveze prema dobavljačima račun {1}
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +102,Ref Date,Ref Datum
@@ -3763,6 +3864,6 @@
 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 +169,Row {0}: Debit entry can not be linked with a {1},Red {0}: debitne unos ne može biti povezan s {1}
-apps/erpnext/erpnext/accounts/doctype/account/account.py +212,Account {0} does not exist,Račun {0} ne postoji
+apps/erpnext/erpnext/accounts/doctype/account/account.py +209,Account {0} does not exist,Račun {0} ne postoji
 DocType: Account,Cash,Gotovina
 DocType: Employee,Short biography for website and other publications.,Kratka biografija za web stranice i drugih publikacija.
