diff --git a/erpnext/translations/hr.csv b/erpnext/translations/hr.csv
index db652a0..bad6e01 100644
--- a/erpnext/translations/hr.csv
+++ b/erpnext/translations/hr.csv
@@ -44,7 +44,6 @@
 DocType: Exchange Rate Revaluation Account,New Exchange Rate,Novi tečaj
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,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,Please setup Employee Naming System in Human Resource &gt; HR Settings,Postavite sustav imenovanja zaposlenika u Ljudski resursi&gt; HR postavke
 DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
 DocType: Purchase Order,Customer Contact,Kupac Kontakt
 DocType: Shift Type,Enable Auto Attendance,Omogući automatsku posjetu
@@ -96,6 +95,7 @@
 DocType: Support Settings,Support Settings,Postavke za podršku
 apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},Račun {0} dodaje se u podružnici tvrtke {1}
 apps/erpnext/erpnext/erpnext_integrations/doctype/exotel_settings/exotel_settings.py,Invalid credentials,Nevažeće vjerodajnice
+apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Work From Home,Označi rad od kuće
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),Dostupan ITC (bilo u cijelom op. Dijelu)
 DocType: Amazon MWS Settings,Amazon MWS Settings,Amazon MWS postavke
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,Obrada bonova
@@ -389,6 +389,7 @@
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,Propisani postupci
 apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,Prikaži samo POS
 DocType: Supplier Group,Supplier Group Name,Naziv grupe dobavljača
+apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,Mark attendance as <b></b>,Označi prisustvo kao <b></b>
 DocType: Driver,Driving License Categories,Kategorije voznih dozvola
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,Unesite datum isporuke
 DocType: Depreciation Schedule,Make Depreciation Entry,Provjerite Amortizacija unos
@@ -408,7 +409,6 @@
 apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,Pojedinosti o članstvu
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}: potreban Dobavljač u odnosu na plativi račun{2}
 apps/erpnext/erpnext/config/buying.py,Items and Pricing,Stavke i cijene
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kupac&gt; Grupa kupaca&gt; Teritorij
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},Ukupno vrijeme: {0}
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,From Date should be within the Fiscal Year. Assuming From Date = {0},Od datuma trebao biti u fiskalnoj godini. Uz pretpostavku Od datuma = {0}
 DocType: Patient Medical Record,HLC-PMR-.YYYY.-,FHP-PMR-.YYYY.-
@@ -455,7 +455,6 @@
 DocType: Quiz Result,Selected Option,Odabrana opcija
 DocType: SG Creation Tool Course,SG Creation Tool Course,Tečaj SG alat za izradu
 DocType: Bank Statement Transaction Invoice Item,Payment Description,Opis plaćanja
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Postavite Nameing Series za {0} putem Postavke&gt; Postavke&gt; Imenovanje serija
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,nedovoljna Stock
 DocType: Email Digest,New Sales Orders,Nove narudžbenice
 DocType: Bank Account,Bank Account,Žiro račun
@@ -774,6 +773,7 @@
 DocType: Healthcare Settings,Require Lab Test Approval,Potrebno odobrenje laboratorijskog ispitivanja
 DocType: Attendance,Working Hours,Radnih sati
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,Ukupno izvanredno
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2}
 DocType: Naming Series,Change the starting / current sequence number of an existing series.,Promjena polaznu / tekući redni broj postojeće serije.
 DocType: Accounts Settings,Percentage you are allowed to bill more against the amount ordered. For example: If the order value is $100 for an item and tolerance is set as 10% then you are allowed to bill for $110.,"Postotak koji vam dopušta naplatu više u odnosu na naručeni iznos. Na primjer: Ako je vrijednost narudžbe za artikl 100 USD, a tolerancija postavljena na 10%, tada vam je dopušteno naplaćivanje 110 USD."
 DocType: Dosage Strength,Strength,snaga
@@ -1000,6 +1000,7 @@
 DocType: Company,Delete Company Transactions,Brisanje transakcije tvrtke
 DocType: Production Plan Item,Quantity and Description,Količina i opis
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference No and Reference Date is mandatory for Bank transaction,Referentni broj i reference Datum obvezna je za banke transakcije
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Postavite Nameing Series za {0} putem Postavke&gt; Postavke&gt; Imenovanje serija
 DocType: Purchase Receipt,Add / Edit Taxes and Charges,Dodaj / uredi porez i pristojbe
 DocType: Payment Entry Reference,Supplier Invoice No,Dobavljač Račun br
 DocType: Territory,For reference,Za referencu
@@ -1262,7 +1263,6 @@
 DocType: Pricing Rule Item Group,Pricing Rule Item Group,Skupina stavki pravila o cijenama
 DocType: Travel Itinerary,Travel To,Putovati u
 apps/erpnext/erpnext/config/accounts.py,Exchange Rate Revaluation master.,Master master revalorizacije tečaja
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Postavite brojevnu seriju za Attendance putem Postavljanje&gt; Numeriranje serija
 apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Write Off Amount,Napišite paušalni iznos
 DocType: Leave Block List Allow,Allow User,Dopusti korisnika
 DocType: Journal Entry,Bill No,Bill Ne
@@ -1634,6 +1634,7 @@
 DocType: Sales Team,Incentives,Poticaji
 apps/erpnext/erpnext/accounts/general_ledger.py,Values Out Of Sync,Vrijednosti nisu sinkronizirane
 apps/erpnext/erpnext/stock/report/stock_and_account_value_comparison/stock_and_account_value_comparison.py,Difference Value,Vrijednost razlike
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Postavite brojevnu seriju za Attendance putem Postavljanje&gt; Numeriranje serija
 DocType: SMS Log,Requested Numbers,Traženi brojevi
 DocType: Volunteer,Evening,Večer
 DocType: Quiz,Quiz Configuration,Konfiguracija kviza
@@ -1801,6 +1802,7 @@
 DocType: Student Admission,Publish on website,Objavi na web stranici
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,Datum Dobavljač Račun ne može biti veća od datum knjiženja
 DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod artikla&gt; Grupa artikala&gt; Marka
 DocType: Subscription,Cancelation Date,Datum otkazivanja
 DocType: Purchase Invoice Item,Purchase Order Item,Stavka narudžbenice
 DocType: Agriculture Task,Agriculture Task,Zadatak poljoprivrede
@@ -2401,7 +2403,6 @@
 DocType: Target Detail,Target Distribution,Ciljana Distribucija
 DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Finalizacija privremene procjene
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,Uvoz stranaka i adresa
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2}
 DocType: Salary Slip,Bank Account No.,Žiro račun broj
 DocType: Naming Series,This is the number of the last created transaction with this prefix,To je broj zadnjeg stvorio transakcije s ovim prefiksom
 DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
@@ -2794,6 +2795,9 @@
 DocType: Pricing Rule,Supplier Group,Grupa dobavljača
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0} Digest
 apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From Time and To Time of {1} is overlapping with {2},Red {0}: S vremena i na vrijeme od {1} je preklapanje s {2}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,"A BOM with name {0} already exists for item {1}.
+					<br> Did you rename the item? Please contact Administrator / Tech support
+				",Za stavku {1} već postoji BOM s nazivom {0}. <br> Jeste li preimenovali predmet? Molimo kontaktirajte administratora / tehničku podršku
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,Stock Obveze
 DocType: Purchase Invoice,Supplier Warehouse,Dobavljač galerija
 DocType: Opportunity,Contact Mobile No,Kontak GSM
@@ -3235,6 +3239,7 @@
 DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
 DocType: Quality Meeting Table,Quality Meeting Table,Stol za sastanke o kvaliteti
 apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,Posjetite forume
+apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot complete task {0} as its dependant task {1} are not ccompleted / cancelled.,Ne mogu dovršiti zadatak {0} jer njegov ovisni zadatak {1} nije dovršen / otkazan.
 DocType: Student,Student Mobile Number,Studentski broj mobitela
 DocType: Item,Has Variants,Je Varijante
 DocType: Employee Benefit Claim,Claim Benefit For,Zatražite korist od
@@ -3394,7 +3399,6 @@
 apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,Kreirajte raspored naknada
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,Ponovite kupaca prihoda
 DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Postavite sustav imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja
 DocType: Quiz,Enter 0 to waive limit,Unesite 0 za odricanje od ograničenja
 DocType: Bank Statement Settings,Mapped Items,Mapped Items
 DocType: Amazon MWS Settings,IT,TO
@@ -3428,7 +3432,6 @@
 						Please create or link {1} Assets with respective document.",Nema dovoljno stvorenih sredstava ili povezanih sa {0}. \ Molimo stvorite ili povežite {1} Imovina s odgovarajućim dokumentom.
 DocType: Pricing Rule,Apply Rule On Brand,Primijeni pravilo na marku
 DocType: Task,Actual End Date (via Time Sheet),Stvarni Datum završetka (putem vremenska tablica)
-apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,Zadatak se ne može zatvoriti {0} jer njegov ovisni zadatak {1} nije zatvoren.
 DocType: Soil Texture,Soil Type,Vrsta tla
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},Iznos {0} {1} od {2} {3}
 ,Quotation Trends,Trend ponuda
@@ -3458,6 +3461,7 @@
 DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Stalna ocjena dobavljača
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},Redak {0}: broj materijala koji nije pronađen za stavku {1}
 DocType: Contract Fulfilment Checklist,Requirement,Zahtjev
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Postavite sustav imenovanja zaposlenika u Ljudski resursi&gt; HR postavke
 DocType: Journal Entry,Accounts Receivable,Potraživanja
 DocType: Quality Goal,Objectives,Ciljevi
 DocType: HR Settings,Role Allowed to Create Backdated Leave Application,Uloga je dopuštena za kreiranje sigurnosne aplikacije za odlazak
@@ -3599,6 +3603,7 @@
 DocType: Student Applicant,Applied,primijenjen
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Details of Outward Supplies and inward supplies liable to reverse charge,Pojedinosti o vanjskim potrepštinama i unutarnjim zalihama koje mogu podnijeti povratno punjenje
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,Ponovno otvorena
+apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Lab Test Template,Nije dopušteno. Onemogućite predložak laboratorijskog testa
 DocType: Sales Invoice Item,Qty as per Stock UOM,Količina po skladišnom UOM-u
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Ime Guardian2
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,Root Company
@@ -3657,6 +3662,7 @@
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,Vrsta poslovanja
 DocType: Sales Invoice,Consumer,Potrošač
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"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/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Postavite Nameing Series za {0} putem Postavke&gt; Postavke&gt; Imenovanje serija
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of New Purchase,Trošak kupnje novog
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Order required for Item {0},Prodajnog naloga potrebna za točke {0}
 DocType: Grant Application,Grant Description,Opis potpore
@@ -3682,7 +3688,6 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,"Molimo kliknite na ""Generiraj raspored ' kako bi dobili raspored"
 DocType: Item,"Purchase, Replenishment Details","Pojedinosti o kupnji, dopuni"
 DocType: Products Settings,Enable Field Filters,Omogući filtre polja
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod artikla&gt; Grupa artikala&gt; Marka
 apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also",&quot;Kupčev predmet&quot; također ne može biti predmet kupnje
 DocType: Blanket Order Item,Ordered Quantity,Naručena količina
 apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""","na primjer ""Alati za graditelje"""
@@ -4151,7 +4156,7 @@
 DocType: Authorization Rule,Applicable To (Role),Odnosi se na (uloga)
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,Na čekanju ostavlja
 DocType: BOM Update Tool,Replace BOM,Zamijenite BOM
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,Kod {0} već postoji
+apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Code {0} already exist,Kod {0} već postoji
 DocType: Patient Encounter,Procedures,Postupci
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,Narudžbe za prodaju nisu dostupne za proizvodnju
 DocType: Asset Movement,Purpose,Svrha
@@ -4235,6 +4240,8 @@
 DocType: Grant Application,Grant Application Details ,Pojedinosti o podnošenju zahtjeva
 DocType: Employee Separation,Employee Separation,Razdvajanje zaposlenika
 DocType: BOM Item,Original Item,Izvorna stavka
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Izbrišite zaposlenika <a href=""#Form/Employee/{0}"">{0}</a> \ da biste otkazali ovaj dokument"
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,Datum dokumenta
 apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},Naknada zapisa nastalih - {0}
 DocType: Asset Category Account,Asset Category Account,Imovina Kategorija račun
@@ -4267,6 +4274,7 @@
 DocType: Warranty Claim,Service Address,Usluga Adresa
 apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,Uvoz glavnih podataka
 DocType: Asset Maintenance Task,Calibration,Kalibriranje
+apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Lab Test Item {0} already exist,Predmet laboratorijskog testa {0} već postoji
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0} je praznik tvrtke
 apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,Sati naplate
 apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,Pusti status obavijesti
@@ -4629,7 +4637,7 @@
 ,Salary Register,Plaća Registracija
 DocType: Company,Default warehouse for Sales Return,Zadano skladište za povrat prodaje
 DocType: Pick List,Parent Warehouse,Roditelj Skladište
-DocType: Subscription,Net Total,Osnovica
+DocType: C-Form Invoice Detail,Net Total,Osnovica
 apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Set item's shelf life in days, to set expiry based on manufacturing date plus shelf-life.",Postavite rok trajanja artikala u danima kako biste postavili rok upotrebe na temelju datuma proizvodnje plus rok trajanja.
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Default BOM not found for Item {0} and Project {1},Zadani BOM nije pronađen za stavku {0} i projekt {1}
 apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,Redak {0}: Postavite Način plaćanja u Raspored plaćanja
@@ -4744,7 +4752,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse is mandatory for row {0},Target skladište je obvezno za redom {0}
 apps/erpnext/erpnext/config/retail.py,Retail Operations,Trgovina na malo
 DocType: Cheque Print Template,Primary Settings,Primarne postavke
-DocType: Attendance Request,Work From Home,Rad od kuće
+DocType: Attendance,Work From Home,Rad od kuće
 DocType: Purchase Invoice,Select Supplier Address,Odaberite Dobavljač adresa
 apps/erpnext/erpnext/public/js/event.js,Add Employees,Dodavanje zaposlenika
 DocType: Purchase Invoice Item,Quality Inspection,Provjera kvalitete
@@ -4986,8 +4994,6 @@
 DocType: QuickBooks Migrator,Authorization URL,URL za autorizaciju
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},Iznos {0} {1} {2} {3}
 DocType: Account,Depreciation,Amortizacija
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Izbrišite zaposlenika <a href=""#Form/Employee/{0}"">{0}</a> \ da biste otkazali ovaj dokument"
 apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The number of shares and the share numbers are inconsistent,Broj dionica i brojeva udjela nedosljedni su
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Supplier(s),Dobavljač (s)
 DocType: Employee Attendance Tool,Employee Attendance Tool,Sudjelovanje zaposlenika alat
@@ -5265,6 +5271,7 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Postavljanje Događaji na {0}, budući da je zaposlenik u prilogu niže prodaje osoba nema ID korisnika {1}"
 DocType: Timesheet,Billing Details,Detalji o naplati
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Source and target warehouse must be different,Izvorna i odredišna skladište mora biti drugačiji
+apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,Postavite sustav imenovanja zaposlenika u Ljudski resursi&gt; HR postavke
 apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,Plaćanje neuspjelo. Više pojedinosti potražite u svojem računu za GoCardless
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},Nije dopušteno ažuriranje skladišnih transakcija starijih od {0}
 DocType: Stock Entry,Inspection Required,Inspekcija Obvezno
@@ -5292,7 +5299,6 @@
 DocType: Cheque Print Template,Cheque Height,Ček Visina
 DocType: Supplier,Supplier Details,Dobavljač Detalji
 DocType: Setup Progress,Setup Progress,Postavi napredak
-DocType: Expense Claim,Approval Status,Status odobrenja
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},Od vrijednosti mora biti manje nego vrijednosti u redu {0}
 DocType: Program,Intro Video,Intro video
 DocType: Manufacturing Settings,Default Warehouses for Production,Zadana skladišta za proizvodnju
@@ -5499,6 +5505,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Current BOM and New BOM can not be same,Trenutni troškovnik i novi troškovnik ne mogu biti isti
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,Plaća proklizavanja ID
 apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date Of Retirement must be greater than Date of Joining,Datum umirovljenja mora biti veći od datuma pristupa
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavljač&gt; vrsta dobavljača
 apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,Višestruke inačice
 DocType: Sales Invoice,Against Income Account,Protiv računu dohotka
 apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,{0}% Isporučeno
@@ -5633,7 +5640,6 @@
 apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Slots for {0} are not added to the schedule,Mjesta za {0} ne dodaju se u raspored
 DocType: Product Bundle,List items that form the package.,Popis stavki koje čine paket.
 apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required while transferring Asset {0},Ciljana lokacija potrebna je tijekom prijenosa imovine {0}
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Test Template,Nije dopušteno. Onemogućite predložak testa
 DocType: Sales Invoice,Distance (in km),Udaljenost (u km)
 apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,Postotak izdvajanja mora biti 100 %
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,Odaberite datum knjiženja prije odabira stranku
@@ -5763,7 +5769,6 @@
 DocType: Purchase Invoice,Price List Exchange Rate,Tečaj cjenika
 apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,Sve grupe dobavljača
 DocType: Employee Boarding Activity,Required for Employee Creation,Obavezno za stvaranje zaposlenika
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavljač&gt; vrsta dobavljača
 apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},Broj računa {0} već se koristi u računu {1}
 DocType: GoCardless Mandate,Mandate,Mandat
 DocType: Hotel Room Reservation,Booked,rezerviran
@@ -5829,7 +5834,6 @@
 DocType: Sales Partner,Sales Partner Name,Naziv prodajnog partnera
 apps/erpnext/erpnext/hooks.py,Request for Quotations,Zahtjev za dostavljanje ponuda
 DocType: Payment Reconciliation,Maximum Invoice Amount,Maksimalna Iznos dostavnice
-apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for empty IBAN,BankAccount.validate_iban () nije uspio za prazan IBAN
 DocType: Normal Test Items,Normal Test Items,Normalno ispitne stavke
 DocType: QuickBooks Migrator,Company Settings,Tvrtka Postavke
 DocType: Additional Salary,Overwrite Salary Structure Amount,Prebriši iznos strukture plaće
@@ -5980,6 +5984,7 @@
 DocType: Leave Allocation,Leave Period,Ostavite razdoblje
 DocType: Item,Default Material Request Type,Zadana Materijal Vrsta zahtjeva
 DocType: Supplier Scorecard,Evaluation Period,Razdoblje procjene
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kupac&gt; Grupa kupaca&gt; Teritorij
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,nepoznat
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,Radni nalog nije izrađen
 apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"An amount of {0} already claimed for the component {1},\
@@ -6330,6 +6335,7 @@
 DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Uloga dopušteno postavljanje blokada računa i uređivanje Frozen Entries
 DocType: Supplier Scorecard Scoring Variable,Path,Staza
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,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/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},Faktor konverzije UOM ({0} -&gt; {1}) nije pronađen za stavku: {2}
 DocType: Production Plan,Total Planned Qty,Ukupni planirani broj
 apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Transactions already retreived from the statement,Transakcije su već povučene iz izjave
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,Otvaranje vrijednost
@@ -6338,8 +6344,11 @@
 DocType: Material Request Plan Item,Required Quantity,Potrebna količina
 DocType: Lab Test Template,Lab Test Template,Predložak testa laboratorija
 apps/erpnext/erpnext/accounts/doctype/accounting_period/accounting_period.py,Accounting Period overlaps with {0},Računovodstveno razdoblje se preklapa s {0}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,Dobavljač&gt; vrsta dobavljača
 apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,Račun prodaje
 DocType: Purchase Invoice Item,Total Weight,Totalna tezina
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Izbrišite zaposlenika <a href=""#Form/Employee/{0}"">{0}</a> \ da biste otkazali ovaj dokument"
 DocType: Pick List Item,Pick List Item,Odaberi stavku popisa
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,Komisija za prodaju
 DocType: Job Offer Term,Value / Description,Vrijednost / Opis
@@ -6454,6 +6463,7 @@
 DocType: Contract,Signed On,Potpisan
 DocType: Bank Account,Party Type,Tip stranke
 DocType: Discounted Invoice,Discounted Invoice,Račun s popustom
+apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,Mark attendance as <b></b>,Označi prisustvo kao <b></b>
 DocType: Payment Schedule,Payment Schedule,Raspored plaćanja
 apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},Za određenu vrijednost polja zaposlenika nije pronađen nijedan zaposlenik. &#39;{}&#39;: {}
 DocType: Item Attribute Value,Abbreviation,Skraćenica
@@ -6548,6 +6558,7 @@
 DocType: Purchase Order,To Receive,Primiti
 DocType: Leave Period,Holiday List for Optional Leave,Popis za odmor za izborni dopust
 DocType: Item Tax Template,Tax Rates,Porezne stope
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,Kod artikla&gt; Grupa artikala&gt; Marka
 DocType: Asset,Asset Owner,Vlasnik imovine
 DocType: Item,Website Content,Sadržaj web stranice
 DocType: Bank Account,Integration ID,Integracijski ID
@@ -6555,7 +6566,6 @@
 DocType: Employee,Personal Email,Osobni email
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Variance,Ukupne varijance
 DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Ako je omogućeno, sustav će objaviti računovodstvene stavke za popis automatski."
-apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() accepted invalid IBAN {},BankAccount.validate_iban () prihvatio nevaljanu IBAN {}
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Brokerage,Posredništvo
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Attendance for employee {0} is already marked for this day,Gledatelja za zaposlenika {0} već označena za ovaj dan
 DocType: Work Order Operation,"in Minutes
@@ -6675,6 +6685,7 @@
 DocType: Stock Entry Detail,Additional Cost,Dodatni trošak
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"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"
 DocType: Quality Inspection,Incoming,Dolazni
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Postavite brojevnu seriju za Attendance putem Postavljanje&gt; Numeriranje serija
 apps/erpnext/erpnext/setup/doctype/company/company.js,Default tax templates for sales and purchase are created.,Osnovni su predlošci poreza za prodaju i kupnju.
 apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,Zapis ocjena rezultata {0} već postoji.
 DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.","Primjer: ABCD. #####. Ako je niz postavljen, a transakcije se ne navode u Batch No, tada će se automatski izračunati broj serije na temelju ove serije. Ako uvijek želite izričito spomenuti Nijednu seriju za ovu stavku, ostavite to prazno. Napomena: ta će postavka imati prednost pred Prefiksom serije naziva u Stock Settings."
@@ -6826,6 +6837,7 @@
 apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,Ispiši obrasce IRS 1099
 DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Provjerite zahtijeva li Asset preventivno održavanje ili umjeravanje
 apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,Kratica tvrtke ne može imati više od 5 znakova
+apps/erpnext/erpnext/setup/doctype/company/company.py,Parent Company must be a group company,Matično društvo mora biti tvrtka u grupi
 DocType: Employee,Reports to,Izvješća
 ,Unpaid Expense Claim,Neplaćeni Rashodi Zatraži
 DocType: Payment Entry,Paid Amount,Plaćeni iznos
@@ -6913,6 +6925,7 @@
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Count Count
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,Moraju biti postavljeni datum početka datuma probnog razdoblja i datum završetka probnog razdoblja
 apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,Prosječna stopa
+DocType: Appointment,Appointment With,Sastanak s
 apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Ukupni iznos plaćanja u rasporedu plaćanja mora biti jednak Grand / Rounded Total
 apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate",&quot;Stavka opskrbljena kupcem&quot; ne može imati stopu vrednovanja
 DocType: Subscription Plan Detail,Plan,Plan
@@ -7014,6 +7027,7 @@
 DocType: BOM,Rate Of Materials Based On,Stopa materijali na temelju
 DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.","Ako je omogućeno, polje Akademsko razdoblje bit će obvezno u Alatu za upis na program."
 apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies","Vrijednosti izuzetih, nultih bodova i unutarnjih isporuka bez GST-a"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,Kupac&gt; Grupa kupaca&gt; Teritorij
 apps/erpnext/erpnext/regional/report/datev/datev.py,<b>Company</b> is a mandatory filter.,<b>Tvrtka</b> je obvezan filtar.
 apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,Poništite sve
 DocType: Purchase Taxes and Charges,On Item Quantity,Na Količina predmeta
@@ -7045,7 +7059,6 @@
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Opp / Lead%
 DocType: Bank Guarantee,Bank Account Info,Podaci o bankovnom računu
 DocType: Bank Guarantee,Bank Guarantee Type,Vrsta bankarskog jamstva
-apps/erpnext/erpnext/accounts/doctype/bank_account/test_bank_account.py,BankAccount.validate_iban() failed for valid IBAN {},BankAccount.validate_iban () nije uspio za važeći IBAN {}
 DocType: Payment Schedule,Invoice Portion,Dio dostavnice
 ,Asset Depreciations and Balances,Imovine deprecijacije i sredstva
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} transferred from {2} to {3},Iznos {0} {1} prenesen iz {2} u {3}
@@ -7059,6 +7072,7 @@
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,Nedostatak Kom
 DocType: Purchase Invoice,Input Service Distributor,Distributer ulaznih usluga
 apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,Inačica Stavka {0} postoji s istim atributima
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Postavite sustav imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja
 DocType: Loan,Repay from Salary,Vrati iz plaće
 DocType: Exotel Settings,API Token,API token
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},Zahtjev za isplatu od {0} {1} za iznos {2}
@@ -7709,7 +7723,6 @@
 apps/erpnext/erpnext/crm/doctype/email_campaign/email_campaign.py,Please set up the Campaign Schedule in the Campaign {0},Postavite Raspored kampanje u kampanji {0}
 apps/erpnext/erpnext/config/buying.py,Price List master.,Glavni cjenik.
 DocType: Task,Review Date,Recenzija Datum
-apps/erpnext/erpnext/hr/doctype/attendance/attendance_list.js,Mark attendance as <b></b>,Označi prisustvo kao <b></b>
 DocType: BOM,Allow Alternative Item,Dopusti alternativnu stavku
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Purchase Receipt doesn't have any Item for which Retain Sample is enabled.,Kupnja potvrde nema stavku za koju je omogućen zadržati uzorak.
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,Faktura ukupno
@@ -7937,7 +7950,6 @@
 DocType: Amazon MWS Settings,Max Retry Limit,Maksimalni pokušaj ponovnog pokušaja
 apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,Cjenik nije pronađen
 DocType: Content Activity,Last Activity ,Zadnja aktivnost
-DocType: Student Applicant,Approved,Odobren
 DocType: Pricing Rule,Price,Cijena
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Employee relieved on {0} must be set as 'Left',Zaposlenik razriješen na {0} mora biti postavljen kao 'lijevo '
 DocType: Guardian,Guardian,Čuvar
@@ -8108,6 +8120,7 @@
 DocType: GL Entry,To Rename,Za preimenovanje
 DocType: Stock Entry,Repack,Prepakiraj
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,Odaberite za dodavanje serijskog broja.
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,Postavite sustav imenovanja instruktora u Obrazovanje&gt; Postavke obrazovanja
 apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',Molimo postavite fiskalni kod za kupca &#39;% s&#39;
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,Najprije odaberite tvrtku
 DocType: Item Attribute,Numeric Values,Brojčane vrijednosti
@@ -8124,6 +8137,7 @@
 apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,Košarica je prazna
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Item {0} has no Serial No. Only serilialized items \
 						can have delivery based on Serial No",Stavka {0} nema serijski broj. Samo serijalizirane stavke \ mogu imati isporuku na temelju serijskog br
+apps/erpnext/erpnext/assets/report/fixed_asset_register/fixed_asset_register.py,Depreciated Amount,Amortizirani iznos
 DocType: Vehicle,Model,Model
 DocType: Work Order,Actual Operating Cost,Stvarni operativni trošak
 DocType: Payment Entry,Cheque/Reference No,Ček / Referentni broj
