diff --git a/erpnext/translations/sk.csv b/erpnext/translations/sk.csv
index 36d72fc..d471090 100644
--- a/erpnext/translations/sk.csv
+++ b/erpnext/translations/sk.csv
@@ -25,7 +25,7 @@
 DocType: Purchase Order,PO-,NO-
 apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +15,Cannot transfer Employee with status Left,Nie je možné previesť zamestnanca so stavom doľava
 DocType: Vehicle Service,Mileage,Najazdené
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +303,Do you really want to scrap this asset?,Naozaj chcete zrušiť túto pohľadávku?
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +309,Do you really want to scrap this asset?,Naozaj chcete zrušiť túto pohľadávku?
 DocType: Drug Prescription,Update Schedule,Aktualizovať plán
 apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Vybrať Predvolené Dodávateľ
 DocType: Exchange Rate Revaluation Account,New Exchange Rate,Nový kurz
@@ -37,9 +37,9 @@
 DocType: Employee,Job Applicant,Job Žadatel
 apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,To je založené na transakciách proti tomuto dodávateľovi. Pozri časovú os nižšie podrobnosti
 DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Percento nadprodukcie pre pracovnú objednávku
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +322,Legal,Právne
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +327,Legal,Právne
 DocType: Shopify Settings,Sales Order Series,Séria objednávok
-apps/erpnext/erpnext/hr/utils.py +209,"More than one selection for {0} not \
+apps/erpnext/erpnext/hr/utils.py +221,"More than one selection for {0} not \
 			allowed",Nie je povolený viac než jeden výber pre {0}
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +193,Actual type tax cannot be included in Item rate in row {0},Aktuálny typ daň nemôže byť zahrnutý v cene Položka v riadku {0}
 DocType: Allowed To Transact With,Allowed To Transact With,Povolené na transakciu s
@@ -82,7 +82,7 @@
 DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Oslobodenie od dane pre zamestnancov
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiál
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +71,Making website,Vytváranie webových stránok
-apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +56,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
+apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +58,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
 			amount and previous claimed amount",Maximálny prínos zamestnanca {0} presahuje {1} sumou {2} zložky žiadosti o dávku v pomere k výške a predchádzajúce nárokovaná čiastka
 DocType: Opening Invoice Creation Tool Item,Quantity,Množstvo
 ,Customers Without Any Sales Transactions,Zákazníci bez akýchkoľvek predajných transakcií
@@ -125,7 +125,6 @@
 DocType: Work Order Operation,Work In Progress,Work in Progress
 apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,"Prosím, vyberte dátum"
 DocType: Finance Book,Finance Book,Finančná kniha
-apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +34,From Date {0} cannot be after To Date {1},Od dátumu {0} nemôže byť po dátumu {1}
 DocType: Daily Work Summary Group,Holiday List,Dovolená Seznam
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Accountant,Účtovník
 DocType: Hub Settings,Selling Price List,Cenník predaja
@@ -187,8 +186,8 @@
 DocType: Accounts Settings,Use Custom Cash Flow Format,Použiť formát vlastného toku peňazí
 DocType: SMS Center,All Sales Person,Všichni obchodní zástupci
 DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Mesačný Distribúcia ** umožňuje distribuovať Rozpočet / Target celé mesiace, ak máte sezónnosti vo vašej firme."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1762,Not items found,nenájdený položiek
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +228,Salary Structure Missing,Plat Štruktúra Chýbajúce
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1758,Not items found,nenájdený položiek
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +247,Salary Structure Missing,Plat Štruktúra Chýbajúce
 DocType: Lead,Person Name,Osoba Meno
 DocType: Sales Invoice Item,Sales Invoice Item,Prodejní faktuře položka
 DocType: Account,Credit,Úvěr
@@ -203,12 +202,12 @@
 DocType: Tax Rule,Tax Type,Typ dane
 ,Completed Work Orders,Dokončené pracovné príkazy
 DocType: Support Settings,Forum Posts,Fórum príspevky
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +590,Taxable Amount,Zdaniteľná čiastka
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +594,Taxable Amount,Zdaniteľná čiastka
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
 DocType: Leave Policy,Leave Policy Details,Nechajte detaily pravidiel
 DocType: BOM,Item Image (if not slideshow),Item Image (ne-li slideshow)
 DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hodina Rate / 60) * Skutočná Prevádzková doba
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1101,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Riadok # {0}: Typ referenčného dokumentu musí byť jeden z nárokov na výdaj alebo denníka
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1105,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Riadok # {0}: Typ referenčného dokumentu musí byť jeden z nárokov na výdaj alebo denníka
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +994,Select BOM,select BOM
 DocType: SMS Log,SMS Log,SMS Log
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Náklady na dodávaných výrobků
@@ -246,7 +245,6 @@
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Výpis z účtu
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Farmaceutické
 DocType: Purchase Invoice Item,Is Fixed Asset,Je dlhodobého majetku
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Prosím, nastavte číselnú sériu pre účasť v programe Setup&gt; Numbering Series"
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +317,"Available qty is {0}, you need {1}","K dispozícii je množstvo {0}, musíte {1}"
 DocType: Expense Claim Detail,Claim Amount,Nárok Částka
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +710,Work Order has been {0},Pracovná objednávka bola {0}
@@ -264,7 +262,7 @@
 DocType: Sales Invoice Item,Delivered By Supplier,Dodáva sa podľa dodávateľa
 DocType: Asset Maintenance Task,Asset Maintenance Task,Úloha údržby majetku
 DocType: SMS Center,All Contact,Vše Kontakt
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,Annual Salary,Ročné Plat
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +213,Annual Salary,Ročné Plat
 DocType: Daily Work Summary,Daily Work Summary,Denná práca Súhrn
 DocType: Period Closing Voucher,Closing Fiscal Year,Uzavření fiskálního roku
 apps/erpnext/erpnext/accounts/party.py +404,{0} {1} is frozen,{0} {1} je zmrazený
@@ -292,6 +290,7 @@
 DocType: Student Admission Program,Minimum Age,Minimálny vek
 apps/erpnext/erpnext/utilities/user_progress.py +190,Example: Basic Mathematics,Príklad: Základné Mathematics
 DocType: Customer,Primary Address,Primárna adresa
+apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +39,Diff Qty,Rozdielové množstvo
 DocType: Production Plan,Material Request Detail,Podrobnosti o vyžiadaní materiálu
 DocType: Selling Settings,Default Quotation Validity Days,Predvolené dni platnosti cenovej ponuky
 apps/erpnext/erpnext/controllers/accounts_controller.py +832,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Chcete-li zahrnout daně na řádku v poměru Položka {0}, daně v řádcích {1} musí být zahrnuty"
@@ -326,7 +325,7 @@
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Celkom hodín: {0}
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},"Od data by měla být v rámci fiskálního roku. Za předpokladu, že od data = {0}"
 DocType: Drug Prescription,Interval,interval
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +229,Preference,prednosť
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Preference,prednosť
 DocType: Grant Application,Individual,Individuální
 DocType: Academic Term,Academics User,akademici Užívateľ
 DocType: Cheque Print Template,Amount In Figure,Na obrázku vyššie
@@ -369,13 +368,13 @@
 DocType: Travel Itinerary,Check-out Date,Dátum odchodu
 DocType: Leave Type,Allow Negative Balance,Povolit záporný zůstatek
 apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Nemôžete odstrániť typ projektu &quot;Externé&quot;
-apps/erpnext/erpnext/public/js/utils.js +213,Select Alternate Item,Vyberte alternatívnu položku
+apps/erpnext/erpnext/public/js/utils.js +214,Select Alternate Item,Vyberte alternatívnu položku
 DocType: Employee,Create User,vytvoriť užívateľa
 DocType: Selling Settings,Default Territory,Výchozí Territory
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televize
 DocType: Work Order Operation,Updated via 'Time Log',"Aktualizováno přes ""Time Log"""
 apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +13,Select the customer or supplier.,Vyberte zákazníka alebo dodávateľa.
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +440,Advance amount cannot be greater than {0} {1},Množstvo vopred nemôže byť väčšia ako {0} {1}
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +444,Advance amount cannot be greater than {0} {1},Množstvo vopred nemôže byť väčšia ako {0} {1}
 apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalCode,JournalCode
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +55,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Časový interval preskočil, slot {0} až {1} presahuje existujúci slot {2} na {3}"
 DocType: Naming Series,Series List for this Transaction,Řada seznam pro tuto transakci
@@ -398,7 +397,7 @@
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Cash from Financing,Čistý peňažný tok z financovania
 apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +65,"Please add the remainig benefits {0} to the application as \
 				pro-rata component",Pridajte zvyšné výhody {0} do aplikácie ako zložka \ pro-rata
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2380,"LocalStorage is full , did not save","Miestne úložisko je plná, nezachránil"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2376,"LocalStorage is full , did not save","Miestne úložisko je plná, nezachránil"
 DocType: Lead,Address & Contact,Adresa a kontakt
 DocType: Leave Allocation,Add unused leaves from previous allocations,Pridať nevyužité listy z predchádzajúcich prídelov
 DocType: Sales Partner,Partner website,webové stránky Partner
@@ -420,13 +419,13 @@
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,To je založené na časových výkazov vytvorených proti tomuto projektu
 ,Open Work Orders,Otvorte pracovné príkazy
 DocType: Payment Term,Credit Months,Kreditné mesiace
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +453,Net Pay cannot be less than 0,Čistý Pay nemôže byť nižšia ako 0
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +472,Net Pay cannot be less than 0,Čistý Pay nemôže byť nižšia ako 0
 DocType: Contract,Fulfilled,splnené
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +126,Relieving Date must be greater than Date of Joining,Uvolnění Datum musí být větší než Datum spojování
 DocType: POS Closing Voucher,Cashier,pokladničné
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +216,Leaves per Year,Listy za rok
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +221,Leaves per Year,Listy za rok
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +162,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Zkontrolujte ""Je Advance"" proti účtu {1}, pokud je to záloha záznam."
-apps/erpnext/erpnext/stock/utils.py +219,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
+apps/erpnext/erpnext/stock/utils.py +245,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
 DocType: Email Digest,Profit & Loss,Zisk & Strata
 apps/erpnext/erpnext/utilities/user_progress.py +147,Litre,liter
 DocType: Task,Total Costing Amount (via Time Sheet),Celková kalkulácie Čiastka (cez Time Sheet)
@@ -452,7 +451,7 @@
 DocType: Student Admission,Student Admission,študent Vstupné
 ,Terretory,Terretory
 apps/erpnext/erpnext/stock/doctype/item/item.py +785,Item {0} is cancelled,Položka {0} je zrušená
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +195,Depreciation Row {0}: Depreciation Start Date is entered as past date,Odpisový riadok {0}: Dátum začiatku odpisovania sa zadáva ako posledný dátum
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +206,Depreciation Row {0}: Depreciation Start Date is entered as past date,Odpisový riadok {0}: Dátum začiatku odpisovania sa zadáva ako posledný dátum
 DocType: Contract Template,Fulfilment Terms and Conditions,Zmluvné podmienky plnenia
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1069,Material Request,Požiadavka na materiál
 DocType: Bank Reconciliation,Update Clearance Date,Aktualizace Výprodej Datum
@@ -579,7 +578,7 @@
 DocType: Support Search Source,Response Result Key Path,Cesta kľúča výsledku odpovede
 DocType: Journal Entry,Inter Company Journal Entry,Inter company Journal Entry
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +496,For quantity {0} should not be grater than work order quantity {1},Pre množstvo {0} by nemalo byť väčšie ako množstvo pracovnej objednávky {1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +474,Please see attachment,"Prosím, viz příloha"
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +493,Please see attachment,"Prosím, viz příloha"
 DocType: Purchase Order,% Received,% Prijaté
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Vytvorenie skupiny študentov
 DocType: Volunteer,Weekends,víkendy
@@ -619,7 +618,7 @@
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +72,Total Outstanding,Celkom nevybavené
 DocType: Naming Series,Change the starting / current sequence number of an existing series.,Změnit výchozí / aktuální pořadové číslo existujícího série.
 DocType: Dosage Strength,Strength,pevnosť
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1542,Create a new Customer,Vytvoriť nový zákazník
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1538,Create a new Customer,Vytvoriť nový zákazník
 apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py +17,Expiring On,Vypršanie zapnuté
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Je-li více pravidla pro tvorbu cen i nadále přednost, jsou uživatelé vyzváni k nastavení priority pro vyřešení konfliktu."
 apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,vytvorenie objednávok
@@ -650,7 +649,7 @@
 DocType: Purchase Invoice Item,Quantity and Rate,Množstvo a Sadzba
 DocType: Delivery Note,% Installed,% Inštalovaných
 apps/erpnext/erpnext/utilities/user_progress.py +230,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učebne / etc laboratória, kde môžu byť naplánované prednášky."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1148,Company currencies of both the companies should match for Inter Company Transactions.,Spoločné meny oboch spoločností by mali zodpovedať transakciám medzi spoločnosťami.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1149,Company currencies of both the companies should match for Inter Company Transactions.,Spoločné meny oboch spoločností by mali zodpovedať transakciám medzi spoločnosťami.
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +95,Please enter company name first,"Prosím, zadajte najprv názov spoločnosti"
 DocType: Travel Itinerary,Non-Vegetarian,Non-vegetariánska
 DocType: Purchase Invoice,Supplier Name,Názov dodávateľa
@@ -733,7 +732,7 @@
 DocType: Employee Tax Exemption Proof Submission,Rented From Date,Prenajaté od dátumu
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23,Enough Parts to Build,Dosť Časti vybudovať
 DocType: POS Profile User,POS Profile User,Používateľ profilu POS
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +174,Row {0}: Depreciation Start Date is required,Riadok {0}: Vyžaduje sa dátum začiatku odpisovania
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +185,Row {0}: Depreciation Start Date is required,Riadok {0}: Vyžaduje sa dátum začiatku odpisovania
 DocType: Sales Invoice Item,Service Start Date,Dátum začiatku služby
 DocType: Subscription Invoice,Subscription Invoice,Faktúra odberu
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Direct Income,Přímý příjmů
@@ -775,7 +774,7 @@
 apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Informácie o type dobrovoľníka.
 DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Šablóna mapovania peňažných tokov
 DocType: Travel Request,Costing Details,Podrobnosti o kalkulácii
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2560,Serial no item cannot be a fraction,Sériovej žiadna položka nemôže byť zlomkom
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2556,Serial no item cannot be a fraction,Sériovej žiadna položka nemôže byť zlomkom
 DocType: Journal Entry,Difference (Dr - Cr),Rozdíl (Dr - Cr)
 DocType: Bank Guarantee,Providing,ak
 DocType: Account,Profit and Loss,Zisk a strata
@@ -808,7 +807,7 @@
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +822,Unblock Invoice,Odblokovať faktúru
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Prírastok nemôže byť 0
 DocType: Company,Delete Company Transactions,Zmazať transakcie spoločnosti
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +365,Reference No and Reference Date is mandatory for Bank transaction,Referenčné číslo a referenčný dátum je povinný pre bankové transakcie
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +366,Reference No and Reference Date is mandatory for Bank transaction,Referenčné číslo a referenčný dátum je povinný pre bankové transakcie
 DocType: Purchase Receipt,Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatků
 DocType: Payment Entry Reference,Supplier Invoice No,Dodávateľská faktúra č
 DocType: Territory,For reference,Pro srovnání
@@ -861,6 +860,7 @@
 apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Dodáva: {0}
 DocType: Bank Statement Transaction Entry,Payable Account,Splatnost účtu
 DocType: Payment Entry,Type of Payment,typ platby
+apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +18,Half Day Date is mandatory,Polovičný dátum je povinný
 DocType: Sales Order,Billing and Delivery Status,Stav fakturácie a dodania
 DocType: Job Applicant,Resume Attachment,Resume Attachment
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Verní zákazníci
@@ -968,7 +968,7 @@
 DocType: Fee Validity,Max number of visit,Maximálny počet návštev
 ,Hotel Room Occupancy,Hotel Occupancy
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +386,Timesheet created:,Harmonogramu vytvorenia:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1053,Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1054,Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0}
 apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,zapísať
 DocType: GST Settings,GST Settings,Nastavenia GST
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +81,Currency should be same as Price List Currency: {0},Mena by mala byť rovnaká ako mena cenníka: {0}
@@ -988,6 +988,7 @@
 DocType: Contract,Contract Template,Šablóna zmluvy
 DocType: Clinical Procedure Item,Transfer Qty,Množstvo prenosu
 DocType: Purchase Invoice Item,Asset Location,Umiestnenie majetku
+DocType: Tax Rule,Shipping Zipcode,Prepravný PSČ
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Zverejnenie
 DocType: Accounts Settings,Report Settings,Nastavenia prehľadov
 DocType: Activity Cost,Projects User,Projekty uživatele
@@ -1045,7 +1046,7 @@
 DocType: Account,Accounts,Účty
 DocType: Vehicle,Odometer Value (Last),Hodnota počítadla kilometrov (Last)
 apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Šablóny kritérií kritérií pre dodávateľa.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +311,Marketing,Marketing
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +316,Marketing,Marketing
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303,Payment Entry is already created,Vstup Platba je už vytvorili
 DocType: Request for Quotation,Get Suppliers,Získajte dodávateľov
 DocType: Purchase Receipt Item Supplied,Current Stock,Current skladem
@@ -1055,7 +1056,7 @@
 DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
 apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,"Môžete obnoviť iba vtedy, ak vaše členstvo uplynie do 30 dní"
 DocType: Shopping Cart Settings,Show Stock Availability,Zobraziť dostupnosť zásob
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +487,Set {0} in asset category {1} or company {2},Nastavte {0} v kategórii majetku {1} alebo v spoločnosti {2}
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +510,Set {0} in asset category {1} or company {2},Nastavte {0} v kategórii majetku {1} alebo v spoločnosti {2}
 DocType: Land Unit,Longitude,zemepisná dĺžka
 ,Absent Student Report,Absent Študent Report
 DocType: Crop,Crop Spacing UOM,Rozmiestnenie medzných plôch
@@ -1088,7 +1089,7 @@
 apps/erpnext/erpnext/utilities/transaction_base.py +29,Invalid Posting Time,Neplatný čas odoslania
 DocType: Salary Component,Condition and Formula,Podmienka a vzorec
 DocType: Lead,Campaign Name,Název kampaně
-apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +34,There is no leave period in between {0} and {1},Neexistuje žiadne obdobie dovolenky medzi {0} a {1}
+apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +61,There is no leave period in between {0} and {1},Neexistuje žiadne obdobie dovolenky medzi {0} a {1}
 DocType: Hotel Room,Capacity,kapacita
 DocType: Travel Request Costing,Expense Type,Typ výdavkov
 DocType: Selling Settings,Close Opportunity After Days,Close Opportunity po niekoľkých dňoch
@@ -1139,7 +1140,7 @@
 DocType: Asset,Maintenance,Údržba
 DocType: Subscriber,Subscriber,predplatiteľ
 DocType: Item Attribute Value,Item Attribute Value,Položka Hodnota atributu
-apps/erpnext/erpnext/projects/doctype/project/project.py +406,Please Update your Project Status,Aktualizujte stav projektu
+apps/erpnext/erpnext/projects/doctype/project/project.py +410,Please Update your Project Status,Aktualizujte stav projektu
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +26,Currency Exchange must be applicable for Buying or for Selling.,Výmena peňazí musí byť uplatniteľná pri kúpe alebo predaji.
 DocType: Item,Maximum sample quantity that can be retained,"Maximálne množstvo vzorky, ktoré možno uchovať"
 DocType: Project Update,How is the Project Progressing Right Now?,Ako teraz práca prebieha?
@@ -1195,6 +1196,7 @@
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27,Add Timeslots,Pridať Timeslots
 apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +140,Asset scrapped via Journal Entry {0},Asset vyhodený cez položka denníka {0}
 DocType: Loan,Interest Income Account,Účet Úrokové výnosy
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +42,Max benefits should be greater than zero to dispense benefits,"Maximálne prínosy by mali byť väčšie ako nula, aby sa vylúčili prínosy"
 apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Recenzia pozvánky odoslaná
 DocType: Shift Assignment,Shift Assignment,Presunutie posunu
 DocType: Employee Transfer Property,Employee Transfer Property,Vlastníctvo prevodu zamestnancov
@@ -1229,7 +1231,7 @@
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Laboratórne testy a vitálne znaky
 DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Detail bankového odsúhlasenia
 apps/erpnext/erpnext/controllers/accounts_controller.py +643,Row #{0}: Asset {1} must be submitted,Riadok # {0}: {1} Asset musia byť predložené
-apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +43,No employee found,Nenájdený žiadny zamestnanec
+apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +50,No employee found,Nenájdený žiadny zamestnanec
 DocType: Item,If subcontracted to a vendor,Ak sa subdodávky na dodávateľa
 apps/erpnext/erpnext/education/doctype/student_group/student_group.js +113,Student Group is already updated.,Skupina študentov je už aktualizovaná.
 apps/erpnext/erpnext/education/doctype/student_group/student_group.js +113,Student Group is already updated.,Skupina študentov je už aktualizovaná.
@@ -1300,6 +1302,7 @@
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,otvorená robiť
 DocType: Issue,Via Customer Portal,Prostredníctvom zákazníckeho portálu
 DocType: Notification Control,Delivery Note Message,Delivery Note Message
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Zákaznícka skupina&gt; Územie
 DocType: Lab Test Template,Result Format,Formát výsledkov
 DocType: Expense Claim,Expenses,Výdaje
 DocType: Item Variant Attribute,Item Variant Attribute,Vlastnosť Variantu Položky
@@ -1307,7 +1310,7 @@
 DocType: Payroll Entry,Bimonthly,dvojmesačne
 DocType: Vehicle Service,Brake Pad,Brzdová doštička
 DocType: Fertilizer,Fertilizer Contents,Obsah hnojiva
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +321,Research & Development,Výzkum a vývoj
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +326,Research & Development,Výzkum a vývoj
 apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Částka k Fakturaci
 DocType: Company,Registration Details,Registrace Podrobnosti
 DocType: Timesheet,Total Billed Amount,Celková suma Fakturovaný
@@ -1319,7 +1322,7 @@
 DocType: SMS Log,Requested Numbers,Požadované Čísla
 DocType: Volunteer,Evening,Večer
 DocType: Customer,Bypass credit limit check at Sales Order,Zablokujte kontrolu kreditného limitu na objednávke
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Povolenie &quot;použitia na nákupného košíka&quot;, ako je povolené Nákupný košík a tam by mala byť aspoň jedna daňové pravidlá pre Košík"
+apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +104,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Povolenie &quot;použitia na nákupného košíka&quot;, ako je povolené Nákupný košík a tam by mala byť aspoň jedna daňové pravidlá pre Košík"
 apps/erpnext/erpnext/controllers/accounts_controller.py +445,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Platba Vstup {0} je prepojený na objednávku {1}, skontrolujte, či by mal byť ťahaný za pokrok v tejto faktúre."
 DocType: Sales Invoice Item,Stock Details,Detaily zásob
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Hodnota projektu
@@ -1379,7 +1382,7 @@
 apps/erpnext/erpnext/public/js/hub/hub_listing.js +58,Favourites,Obľúbené
 DocType: Hub Settings,Custom Data,Vlastné údaje
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126,Warehouses with existing transaction can not be converted to ledger.,Sklady s existujúcimi transakcie nemožno previesť na knihy.
-apps/erpnext/erpnext/controllers/buying_controller.py +551,Serial no is mandatory for the item {0},Sériové číslo je povinné pre položku {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +553,Serial no is mandatory for the item {0},Sériové číslo je povinné pre položku {0}
 DocType: Bank Reconciliation,Total Amount,Celková částka
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Internet Publishing
 DocType: Prescription Duration,Number,číslo
@@ -1404,7 +1407,7 @@
 DocType: Woocommerce Settings,Endpoints,Endpoints
 apps/erpnext/erpnext/stock/doctype/item/item.py +677,Item Variants {0} updated,Varianty Položky {0} aktualizované
 DocType: Quality Inspection Reading,Reading 6,Čtení 6
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +959,Cannot {0} {1} {2} without any negative outstanding invoice,Nemožno {0} {1} {2} bez negatívnych vynikajúce faktúra
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +963,Cannot {0} {1} {2} without any negative outstanding invoice,Nemožno {0} {1} {2} bez negatívnych vynikajúce faktúra
 DocType: Share Transfer,From Folio No,Z Folio č
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Záloha přijaté faktury
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +231,Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
@@ -1424,14 +1427,14 @@
 DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,Prijatá faktúra
 DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,Povoliť viacnásobnú spotrebu materiálu proti pracovnej objednávke
 DocType: GL Entry,Voucher Detail No,Voucher Detail No
-apps/erpnext/erpnext/accounts/page/pos/pos.js +797,New Sales Invoice,Nová predajná faktúra
+apps/erpnext/erpnext/accounts/page/pos/pos.js +793,New Sales Invoice,Nová predajná faktúra
 DocType: Stock Entry,Total Outgoing Value,Celková hodnota Odchozí
 DocType: Physician,Appointments,schôdzky
 apps/erpnext/erpnext/public/js/account_tree_grid.js +223,Opening Date and Closing Date should be within same Fiscal Year,Dátum začatia a dátumom ukončenia by malo byť v rámci rovnakého fiškálny rok
 DocType: Lead,Request for Information,Žádost o informace
 ,LeaderBoard,Nástenka lídrov
 DocType: Sales Invoice Item,Rate With Margin (Company Currency),Sadzba s maržou (mena spoločnosti)
-apps/erpnext/erpnext/accounts/page/pos/pos.js +810,Sync Offline Invoices,Sync Offline Faktúry
+apps/erpnext/erpnext/accounts/page/pos/pos.js +806,Sync Offline Invoices,Sync Offline Faktúry
 DocType: Payment Request,Paid,Zaplatené
 DocType: Program Fee,Program Fee,program Fee
 DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
@@ -1491,12 +1494,13 @@
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +46,Save Settings,Uložiť nastavenia
 DocType: Delivery Stop,Notified by Email,Oznámené e-mailom
 apps/erpnext/erpnext/templates/pages/help.html +29,See All Articles,Pozrite si všetky články
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Walk In,Vejít
 DocType: Item,Inspection Criteria,Inšpekčné kritéria
 apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Prevedené
 DocType: BOM Website Item,BOM Website Item,BOM Website Item
 apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Nahrajte svoju hlavičku a logo pre dokumenty. (Môžete ich upravovať neskôr.)
 DocType: Timesheet Detail,Bill,Účtenka
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,White,Biela
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +183,White,Biela
 DocType: SMS Center,All Lead (Open),Všetky Iniciatívy (Otvorené)
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +314,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Riadok {0}: Množstvo nie je k dispozícii pre {4} v sklade {1} pri účtovaní čas zápisu ({2} {3})
 apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,V zozname začiarkavacích políčok môžete vybrať maximálne jednu možnosť.
@@ -1515,6 +1519,7 @@
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Otevření POČET
 DocType: Healthcare Settings,Appointment Reminder,Pripomienka na menovanie
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +483,Please enter Account for Change Amount,"Prosím, zadajte účet pre zmenu Suma"
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,"Prosím, nastavte názov inštruktora systému vo vzdelávaní&gt; Nastavenia vzdelávania"
 DocType: Program Enrollment Tool Student,Student Batch Name,Študent Batch Name
 DocType: Consultation,Doctor,lekár
 DocType: Holiday List,Holiday List Name,Názov zoznamu sviatkov
@@ -1522,10 +1527,10 @@
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +132,Added to details,Pridané k podrobnostiam
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,rozvrh
 DocType: Budget,Applicable on Material Request,Platí pre materiálové požiadavky
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +212,Stock Options,Možnosti zásob
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +217,Stock Options,Možnosti zásob
 DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Zakázať načítanie posledných detailov nákupu v objednávke
 DocType: Journal Entry Account,Expense Claim,Hrazení nákladů
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +317,Do you really want to restore this scrapped asset?,Naozaj chcete obnoviť tento vyradený aktívum?
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +323,Do you really want to restore this scrapped asset?,Naozaj chcete obnoviť tento vyradený aktívum?
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +420,Qty for {0},Množství pro {0}
 DocType: Leave Application,Leave Application,Aplikácia na priepustky
 DocType: Patient,Patient Relation,Vzťah pacientov
@@ -1574,6 +1579,7 @@
 DocType: POS Profile,Sales Invoice Payment,Predajná faktúry Platba
 DocType: Quality Inspection Template,Quality Inspection Template Name,Názov šablóny inšpekcie kvality
 DocType: Project,First Email,Prvý e-mail
+DocType: Company,Exception Budget Approver Role,Role prístupu k výnimke rozpočtu
 DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date",Po nastavení bude táto faktúra pozastavená až do stanoveného dátumu
 DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Vyhrazeno Warehouse v prodejní objednávky / hotových výrobků Warehouse
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Selling Amount,Predajná čiastka
@@ -1607,7 +1613,7 @@
 DocType: Item Default,Default Selling Cost Center,Výchozí Center Prodejní cena
 apps/erpnext/erpnext/public/js/pos/pos.html +85,Disc,kotúč
 DocType: Buying Settings,Material Transferred for Subcontract,Materiál prenesený na subdodávateľskú zmluvu
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1632,ZIP Code,PSČ
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1628,ZIP Code,PSČ
 apps/erpnext/erpnext/controllers/selling_controller.py +253,Sales Order {0} is {1},Predajné objednávky {0} {1}
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +292,Select interest income account in loan {0},Vyberte účet úrokového príjmu v úvere {0}
 DocType: Opportunity,Contact Info,Kontaktní informace
@@ -1673,7 +1679,7 @@
 ,Ordered Items To Be Billed,Objednané zboží fakturovaných
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,"Z rozsahu, musí byť nižšia ako na Range"
 DocType: Global Defaults,Global Defaults,Globální Výchozí
-apps/erpnext/erpnext/projects/doctype/project/project.py +230,Project Collaboration Invitation,Projekt spolupráce Pozvánka
+apps/erpnext/erpnext/projects/doctype/project/project.py +234,Project Collaboration Invitation,Projekt spolupráce Pozvánka
 DocType: Salary Slip,Deductions,Odpočty
 DocType: Leave Allocation,LAL/,LAL /
 DocType: Setup Progress Action,Action Name,Názov akcie
@@ -1700,7 +1706,7 @@
 DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Polia budú kopírované iba v čase vytvorenia.
 DocType: Setup Progress Action,Domains,Domény
 apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date',"""Aktuálny datum začiatku"" nemôže byť väčší ako ""Aktuálny dátum ukončenia"""
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +319,Management,Manažment
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +324,Management,Manažment
 DocType: Cheque Print Template,Payer Settings,nastavenie platcu
 apps/erpnext/erpnext/public/js/utils/party.js +192,Select company first,Najprv vyberte spoločnosť
 DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To bude připojen na položku zákoníku varianty. Například, pokud vaše zkratka je ""SM"", a položka je kód ""T-SHIRT"", položka kód varianty bude ""T-SHIRT-SM"""
@@ -1711,7 +1717,7 @@
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +843,Return / Debit Note,Return / ťarchopis
 DocType: Price List Country,Price List Country,Cenník Krajina
 DocType: Item,UOMs,Merné Jednotky
-apps/erpnext/erpnext/stock/utils.py +212,{0} valid serial nos for Item {1},{0} platné sériové čísla pre položky {1}
+apps/erpnext/erpnext/stock/utils.py +238,{0} valid serial nos for Item {1},{0} platné sériové čísla pre položky {1}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +59,Item Code cannot be changed for Serial No.,Kód položky nemůže být změněn pro Serial No.
 DocType: Purchase Invoice Item,UOM Conversion Factor,Faktor konverzie MJ
 apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js +9,Please enter Item Code to get Batch Number,"Prosím, zadajte kód položky sa dostať číslo šarže"
@@ -1725,7 +1731,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +765,Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
 DocType: Fee Validity,Valid Till,Platný do
 DocType: Student Report Generation Tool,Total Parents Teacher Meeting,Celkové stretnutie učiteľov rodičov
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2521,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Režim platba nie je nakonfigurovaný. Prosím skontrolujte, či je účet bol nastavený na režim platieb alebo na POS Profilu."
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2517,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Režim platba nie je nakonfigurovaný. Prosím skontrolujte, či je účet bol nastavený na režim platieb alebo na POS Profilu."
 apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Rovnakú položku nemožno zadávať viackrát.
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups","Ďalšie účty môžu byť vyrobené v rámci skupiny, ale údaje je možné proti non-skupín"
 DocType: Lead,Lead,Obchodná iniciatíva
@@ -1744,6 +1750,7 @@
 DocType: Student Report Generation Tool,Assessment Terms,Hodnotiace podmienky
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Položka 1
 DocType: Holiday,Holiday,Dovolená
+apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +25,Leave Type is madatory,Druh dovolenky je panikavý
 DocType: Support Settings,Close Issue After Days,Close Issue po niekoľkých dňoch
 DocType: Leave Control Panel,Leave blank if considered for all branches,"Ponechte prázdné, pokud se to považuje za všechny obory"
 DocType: Job Opening,Staffing Plan,Personálny plán
@@ -1835,7 +1842,7 @@
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Predpisy pre laboratórne testy
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +168,"The total Issue / Transfer quantity {0} in Material Request {1}  \
 							cannot be greater than requested quantity {2} for Item {3}",Celkové emisie / prenosu množstvo {0} v hmotnej Request {1} \ nemôže byť väčšie než množstvo {2} pre položku {3}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +173,Small,Malý
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +172,Small,Malý
 DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Ak služba Shopify neobsahuje zákazníka v objednávke, pri synchronizácii objednávok systém zváži objednávku predvoleného zákazníka"
 DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Otvorenie položky nástroja na vytvorenie faktúry
 DocType: Education Settings,Employee Number,Počet zaměstnanců
@@ -1860,25 +1867,25 @@
 apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +15,Create Sales Order,Vytvorenie objednávky predaja
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +493,Accounting Entry for Asset,Účtovné položky pre aktíva
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +828,Block Invoice,Blokovať faktúru
-apps/erpnext/erpnext/accounts/page/pos/pos.js +802,Sync Master Data,Sync Master Data
+apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js +16,Quantity to Make,"Množstvo, ktoré sa má vyrobiť"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +798,Sync Master Data,Sync Master Data
 DocType: Asset Repair,Repair Cost,Náklady na opravu
 apps/erpnext/erpnext/utilities/user_progress.py +138,Your Products or Services,Vaše Produkty alebo Služby
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Nepodarilo sa prihlásiť
-apps/erpnext/erpnext/controllers/buying_controller.py +599,Asset {0} created,Bol vytvorený majetok {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +600,Asset {0} created,Bol vytvorený majetok {0}
 DocType: Special Test Items,Special Test Items,Špeciálne testovacie položky
 DocType: Bank Statement Transaction Payment Item,Mode of Payment,Způsob platby
 apps/erpnext/erpnext/stock/doctype/item/item.py +217,Website Image should be a public file or website URL,Webové stránky Image by mala byť verejná súboru alebo webovej stránky URL
 DocType: Student Applicant,AP,AP
 DocType: Purchase Invoice Item,BOM,BOM
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položiek&gt; Značka
 DocType: Journal Entry Account,Purchase Order,Nákupná objednávka
 DocType: Vehicle,Fuel UOM,palivo UOM
 DocType: Warehouse,Warehouse Contact Info,Sklad Kontaktní informace
 DocType: Payment Entry,Write Off Difference Amount,Odpísať Difference Suma
 DocType: Volunteer,Volunteer Name,Názov dobrovoľníka
 DocType: Leave Period,Carry Forward Leaves,Prenášať listy dopredu
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +485,"{0}: Employee email not found, hence email not sent","{0}: e-mail zamestnanec nebol nájdený, a preto je pošta neposlal"
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +504,"{0}: Employee email not found, hence email not sent","{0}: e-mail zamestnanec nebol nájdený, a preto je pošta neposlal"
 apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +56,No Salary Structure assigned for Employee {0} on given date {1},Žiadna platová štruktúra priradená zamestnancovi {0} v daný deň {1}
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Prepravné pravidlo sa nevzťahuje na krajinu {0}
 DocType: Item,Foreign Trade Details,Zahraničný obchod Podrobnosti
@@ -1890,9 +1897,9 @@
 DocType: Student Group Student,Group Roll Number,Číslo skupiny rollov
 DocType: Student Group Student,Group Roll Number,Číslo skupiny rollov
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +177,"For {0}, only credit accounts can be linked against another debit entry","Pro {0}, tak úvěrové účty mohou být propojeny na jinou položku debetní"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +169,Supplier &gt; Supplier Type,Dodávateľ&gt; Typ dodávateľa
 apps/erpnext/erpnext/projects/doctype/project/project.py +84,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Súčet všetkých váh úloha by mal byť 1. Upravte váhy všetkých úloh projektu v súlade
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +593,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +42,Max benefits should be greater than zero to despense flexi,"Maximálne prínosy by mali byť väčšie ako nula, aby sa znížil flexi"
 apps/erpnext/erpnext/stock/get_item_details.py +158,Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Capital Equipments,Kapitálové Vybavení
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Ceny Pravidlo je nejprve vybrána na základě ""Použít na"" oblasti, které mohou být položky, položky skupiny nebo značky."
@@ -1917,11 +1924,12 @@
 DocType: Patient Appointment,Duration,trvanie
 apps/erpnext/erpnext/controllers/status_updater.py +160,"For an item {0}, quantity must be positive number",Pri položke {0} musí byť množstvo kladné
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +76,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Poznámka: Tento Nákladové středisko je Group. Nelze vytvořit účetní zápisy proti skupinám.
+apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +44,Compensatory leave request days not in valid holidays,Kompenzačné dni žiadosti o dovolenku nie sú v platných sviatkoch
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53,Child warehouse exists for this warehouse. You can not delete this warehouse.,Dieťa sklad existuje pre tento sklad. Nemôžete odstrániť tento sklad.
 DocType: Item,Website Item Groups,Webové stránky skupiny položek
 DocType: Purchase Invoice,Total (Company Currency),Total (Company meny)
 DocType: Daily Work Summary Group,Reminder,pripomienka
-apps/erpnext/erpnext/stock/utils.py +207,Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou
+apps/erpnext/erpnext/stock/utils.py +233,Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou
 DocType: Bank Statement Transaction Invoice Item,Journal Entry,Zápis do deníku
 DocType: Expense Claim Advance,Unclaimed amount,Nevyžiadaná suma
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +165,{0} items in progress,{0} položky v prebiehajúcej
@@ -2020,6 +2028,7 @@
 DocType: Employee,Prefered Email,preferovaný Email
 DocType: Student Admission,Eligibility and Details,Oprávnenosť a podrobnosti
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +92,Net Change in Fixed Asset,Čistá zmena v stálych aktív
+apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +38,Reqd Qty,Požad
 DocType: Leave Control Panel,Leave blank if considered for all designations,Nechajte prázdne ak má platiť pre všetky zadelenia
 apps/erpnext/erpnext/controllers/accounts_controller.py +838,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Obvinění z typu ""Aktuální"" v řádku {0} nemůže být zařazena do položky Rate"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +421,Max: {0},Max: {0}
@@ -2210,7 +2219,7 @@
 DocType: Sales Invoice Item,Brand Name,Jméno značky
 DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55,User {0} is already assigned to Physician {1},Používateľ {0} je už pridelený lekárovi {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2705,Default warehouse is required for selected item,Predvolené sklad je vyžadované pre vybraná položka
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2701,Default warehouse is required for selected item,Predvolené sklad je vyžadované pre vybraná položka
 apps/erpnext/erpnext/utilities/user_progress.py +146,Box,Krabica
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1043,Possible Supplier,možné Dodávateľ
 DocType: Journal Entry,JV-RET-,JV-RET-
@@ -2243,7 +2252,6 @@
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Žádné položky k balení
 DocType: Shipping Rule Condition,From Value,Od hodnoty
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +673,Manufacturing Quantity is mandatory,Výrobné množstvo je povinné
-apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +37,To Date {0} cannot be after employee's relieving Date {1},Dátum {0} nemôže byť po zmiernení zamestnanca Dátum {1}
 DocType: Loan,Repayment Method,splácanie Method
 DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Ak je zaškrtnuté, domovská stránka bude východiskový bod skupina pre webové stránky"
 DocType: Quality Inspection Reading,Reading 4,Čtení 4
@@ -2264,6 +2272,7 @@
 DocType: Student Report Generation Tool,Print Section,Tlačiť sekciu
 DocType: Staffing Plan Detail,Estimated Cost Per Position,Odhadovaná cena za pozíciu
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Používateľ {0} nemá predvolený profil POS. Začiarknite predvolené nastavenie v riadku {1} pre tohto používateľa.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Employee Referral,Odporúčanie zamestnancov
 DocType: Student Group,Set 0 for no limit,Nastavte 0 pre žiadny limit
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +198,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"V deň, keď (y), na ktoré žiadate o povolenie sú prázdniny. Nemusíte požiadať o voľno."
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Row {idx}: {field} je povinný vytvoriť faktúry Opening {invoice_type}
@@ -2284,8 +2293,9 @@
 DocType: HR Settings,Stop Birthday Reminders,Zastaviť pripomenutie narodenín
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +239,Please set Default Payroll Payable Account in Company {0},"Prosím nastaviť predvolený účet mzdy, splatnú v spoločnosti {0}"
 DocType: SMS Center,Receiver List,Přijímač Seznam
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1102,Search Item,hľadanie položky
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1098,Search Item,hľadanie položky
 DocType: Payment Schedule,Payment Amount,Částka platby
+apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +20,Half Day Date should be in between Work From Date and Work End Date,Polovičný dátum by mal byť medzi prácou od dátumu a dátumom ukončenia práce
 DocType: Patient Appointment,Referring Physician,Odporúčajúci lekár
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Consumed Amount,Spotřebovaném množství
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +69,Net Change in Cash,Čistá zmena v hotovosti
@@ -2311,7 +2321,7 @@
 DocType: Purchase Order Item,Supplier Part Number,Dodavatel Číslo dílu
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +124,Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1
 DocType: Share Balance,To No,Nie
-apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +26,All the mandatory Task for employee creation hasn't been done yet.,Všetky povinné úlohy na tvorbu zamestnancov ešte neboli vykonané.
+apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +27,All the mandatory Task for employee creation hasn't been done yet.,Všetky povinné úlohy na tvorbu zamestnancov ešte neboli vykonané.
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +231,{0} {1} is cancelled or stopped,{0} {1} je zrušená alebo zastavená
 DocType: Accounts Settings,Credit Controller,Credit Controller
 DocType: Loan,Applicant Type,Typ žiadateľa
@@ -2342,7 +2352,7 @@
 					or hiring completed as per Staffing Plan {1}",Otvorené pracovné miesta na označenie {0} už otvorené alebo dokončené na základe Personálneho plánu {1}
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
 DocType: Customer,Default Price List,Výchozí Ceník
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +460,Asset Movement record {0} created,Záznam Asset Pohyb {0} vytvoril
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +483,Asset Movement record {0} created,Záznam Asset Pohyb {0} vytvoril
 apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +175,No items found.,Nenašli sa žiadne položky.
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Nemožno odstrániť fiškálny rok {0}. Fiškálny rok {0} je nastavený ako predvolený v globálnom nastavení
 DocType: Share Transfer,Equity/Liability Account,Účet vlastného imania / zodpovednosti
@@ -2395,7 +2405,7 @@
 apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Reklamační proti sériového čísla
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215,'Total',&quot;Celkom&quot;
 DocType: Employee,Permanent Address,Trvalé bydliště
-apps/erpnext/erpnext/hr/utils.py +144,From date can not be less than employee's joining date,Od dátumu nemôže byť menej ako dátum spájania zamestnanca
+apps/erpnext/erpnext/hr/utils.py +156,From date can not be less than employee's joining date,Od dátumu nemôže byť menej ako dátum spájania zamestnanca
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,"Advance paid against {0} {1} cannot be greater \
 						than Grand Total {2}",Vyplatená záloha proti {0} {1} nemôže byť väčšia \ než Grand Celkom {2}
 DocType: Consultation,Medication,liečenie
@@ -2473,7 +2483,6 @@
 DocType: Asset,Depreciation Method,odpisy Metóda
 DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +58,Total Target,Celkem Target
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +25,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosím, nastavte systém pomenovania zamestnancov v oblasti ľudských zdrojov&gt; Nastavenia personálu"
 DocType: Soil Texture,Sand Composition (%),Zloženie piesku (%)
 DocType: Job Applicant,Applicant for a Job,Žadatel o zaměstnání
 DocType: Production Plan Material Request,Production Plan Material Request,Výroba Dopyt Plán Materiál
@@ -2511,7 +2520,7 @@
 DocType: Purchase Order Item,Warehouse and Reference,Sklad a reference
 DocType: Payroll Period Date,Payroll Period Date,Dátum mzdového obdobia
 DocType: Supplier,Statutory info and other general information about your Supplier,Statutární info a další obecné informace o váš dodavatel
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +520,You have to Deduct Tax for Unsubmitted Tax Exemption Proof and Unclaimed Employee Benefits in the last Salary Slip of Payroll Period,Musíte odpočítať daň z nezdaneného daňového oslobodenia od dane a nárok na zamestnanecké požitky v poslednom platovom rozpisu platového obdobia
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +539,You have to Deduct Tax for Unsubmitted Tax Exemption Proof and Unclaimed Employee Benefits in the last Salary Slip of Payroll Period,Musíte odpočítať daň z nezdaneného daňového oslobodenia od dane a nárok na zamestnanecké požitky v poslednom platovom rozpisu platového obdobia
 DocType: Item,Serial Nos and Batches,Sériové čísla a dávky
 DocType: Item,Serial Nos and Batches,Sériové čísla a dávky
 apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Sila študentskej skupiny
@@ -2547,7 +2556,7 @@
 DocType: Budget,Action if Annual Budget Exceeded on PO,"Opatrenie, ak bol prekročený ročný rozpočet na PO"
 DocType: Student Leave Application,Student Leave Application,Študent nechať aplikáciu
 DocType: Item,Will also apply for variants,Bude platiť aj pre varianty
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +277,"Asset cannot be cancelled, as it is already {0}","Asset nemožno zrušiť, pretože je už {0}"
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +288,"Asset cannot be cancelled, as it is already {0}","Asset nemožno zrušiť, pretože je už {0}"
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +31,Employee {0} on Half day on {1},Zamestnancov {0} o pol dňa na {1}
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +51,Total working hours should not be greater than max working hours {0},Celkom pracovná doba by nemala byť väčšia ako maximálna pracovnej doby {0}
 apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Kdy
@@ -2555,13 +2564,14 @@
 DocType: Material Request Plan Item,Actual Qty,Skutečné Množství
 DocType: Sales Invoice Item,References,Referencie
 DocType: Quality Inspection Reading,Reading 10,Čtení 10
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +48,Serial nos {0} does not belongs to the location {1},Sériový nos {0} nepatrí do umiestnenia {1}
 DocType: Item,Barcodes,čiarové kódy
 DocType: Hub Category,Hub Node,Hub Node
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,"Zadali jste duplicitní položky. Prosím, opravu a zkuste to znovu."
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Associate,Spolupracovník
 DocType: Asset Movement,Asset Movement,asset Movement
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +567,Work Order {0} must be submitted,Musí sa odoslať pracovná objednávka {0}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2219,New Cart,new košík
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2215,New Cart,new košík
 DocType: Taxable Salary Slab,From Amount,Z čiastky
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Položka {0} není serializovat položky
 DocType: Leave Type,Encashment,inkaso
@@ -2594,6 +2604,7 @@
 DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Získat položky z Příjmového listu
 DocType: Serial No,Creation Date,Datum vytvoření
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Položka {0} se objeví několikrát v Ceníku {1}
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +55,Target Location is required for the asset {0},Miesto cieľa je požadované pre majetok {0}
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +42,"Selling must be checked, if Applicable For is selected as {0}","Prodej musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
 DocType: Production Plan Material Request,Material Request Date,Materiál Request Date
 DocType: Purchase Order Item,Supplier Quotation Item,Položka dodávateľskej ponuky
@@ -2603,7 +2614,7 @@
 DocType: Item,Has Variants,Má varianty
 apps/erpnext/erpnext/controllers/accounts_controller.py +521,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Nie je možné prepísať položku {0} v riadku {1} viac ako {2}. Ak chcete povoliť nadmerné fakturácie, nastavte prosím nastavenia v ponuke"
 apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Aktualizácia odpovede
-apps/erpnext/erpnext/public/js/utils.js +397,You have already selected items from {0} {1},Už ste vybrané položky z {0} {1}
+apps/erpnext/erpnext/public/js/utils.js +398,You have already selected items from {0} {1},Už ste vybrané položky z {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Název měsíční výplatou
 apps/erpnext/erpnext/stock/doctype/batch/batch.py +100,Batch ID is mandatory,Číslo šarže je povinné
 apps/erpnext/erpnext/stock/doctype/batch/batch.py +100,Batch ID is mandatory,Číslo šarže je povinné
@@ -2617,7 +2628,7 @@
 DocType: Supplier,Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
 DocType: Budget,Fiscal Year,Fiškálny rok
 DocType: Asset Maintenance Log,Planned,plánovaná
-apps/erpnext/erpnext/hr/utils.py +186,A {0} exists between {1} and {2} (,A {0} existuje medzi {1} a {2} (
+apps/erpnext/erpnext/hr/utils.py +198,A {0} exists between {1} and {2} (,A {0} existuje medzi {1} a {2} (
 DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,"Predvolené pohľadávky, ktoré sa majú použiť, ak nie sú stanovené v pacientovi, aby si rezervovali poplatky za konzultácie."
 DocType: Vehicle Log,Fuel Price,palivo Cena
 DocType: Bank Guarantee,Margin Money,Margin Money
@@ -2625,7 +2636,7 @@
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +80,Set Open,Otvorte Otvoriť
 apps/erpnext/erpnext/stock/doctype/item/item.py +273,Fixed Asset Item must be a non-stock item.,Fixed Asset položky musia byť non-skladová položka.
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +52,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Rozpočet nemožno priradiť proti {0}, pretože to nie je výnos alebo náklad účet"
-apps/erpnext/erpnext/hr/utils.py +215,Max exemption amount for {0} is {1},Maximálna výška výnimky pre {0} je {1}
+apps/erpnext/erpnext/hr/utils.py +227,Max exemption amount for {0} is {1},Maximálna výška výnimky pre {0} je {1}
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Dosažená
 DocType: Student Admission,Application Form Route,prihláška Trasa
 apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Territory / Customer
@@ -2660,7 +2671,7 @@
  musí být větší než nebo rovno {2}"
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,To je založené na akciovom pohybu. Pozri {0} Podrobnosti
 DocType: Pricing Rule,Selling,Predaj
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +393,Amount {0} {1} deducted against {2},Množstvo {0} {1} odpočítať proti {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +394,Amount {0} {1} deducted against {2},Množstvo {0} {1} odpočítať proti {2}
 DocType: Employee,Salary Information,Vyjednávání o platu
 DocType: Sales Person,Name and Employee ID,Meno a ID zamestnanca
 apps/erpnext/erpnext/accounts/party.py +320,Due Date cannot be before Posting Date,Datum splatnosti nesmí být před odesláním Datum
@@ -2674,7 +2685,7 @@
 DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabuľka k Položke, která sa zobrazí na webových stránkách"
 DocType: Purchase Order Item Supplied,Supplied Qty,Dodávané Množstvo
 DocType: Purchase Order Item,Material Request Item,Materiál Žádost o bod
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +283,Please cancel Purchase Receipt {0} first,Najprv zrušte nákupnú knižku {0}
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +294,Please cancel Purchase Receipt {0} first,Najprv zrušte nákupnú knižku {0}
 apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Strom skupiny položek.
 DocType: Production Plan,Total Produced Qty,Celkový vyrobený počet
 DocType: Payroll Entry,Get Employee Details,Získajte podrobnosti o zamestnancoch
@@ -2735,8 +2746,8 @@
 DocType: Employee,Resignation Letter Date,Rezignace Letter Datum
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +115,Not Set,Nenastavené
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +379,Please set the Date Of Joining for employee {0},Nastavte dátum založenia pre zamestnanca {0}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +379,Please set the Date Of Joining for employee {0},Nastavte dátum založenia pre zamestnanca {0}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +398,Please set the Date Of Joining for employee {0},Nastavte dátum založenia pre zamestnanca {0}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +398,Please set the Date Of Joining for employee {0},Nastavte dátum založenia pre zamestnanca {0}
 DocType: Task,Total Billing Amount (via Time Sheet),Celková suma Billing (cez Time Sheet)
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Repeat Customer Příjmy
 DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
@@ -2752,7 +2763,7 @@
 DocType: Maintenance Schedule Detail,Actual Date,Skutečné datum
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139,Please set the Default Cost Center in {0} company.,Nastavte štandardné cenové centrum v spoločnosti {0}.
 DocType: Item,Has Batch No,Má číslo šarže
-apps/erpnext/erpnext/public/js/utils.js +106,Annual Billing: {0},Ročný Billing: {0}
+apps/erpnext/erpnext/public/js/utils.js +107,Annual Billing: {0},Ročný Billing: {0}
 DocType: Shopify Webhook Detail,Shopify Webhook Detail,Nakupujte podrobnosti Webhook
 apps/erpnext/erpnext/config/accounts.py +206,Goods and Services Tax (GST India),Daň z tovarov a služieb (GST India)
 DocType: Delivery Note,Excise Page Number,Spotřební Číslo stránky
@@ -2766,7 +2777,7 @@
 ,Maintenance Schedules,Plány údržby
 DocType: Task,Actual End Date (via Time Sheet),Skutočný dátum ukončenia (cez Time Sheet)
 DocType: Soil Texture,Soil Type,Typ pôdy
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +388,Amount {0} {1} against {2} {3},Množstvo {0} {1} na {2} {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +389,Amount {0} {1} against {2} {3},Množstvo {0} {1} na {2} {3}
 ,Quotation Trends,Vývoje ponúk
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +166,Item Group not mentioned in item master for item {0},Položková skupina nie je uvedená v hlavnej položke pre  položku {0}
 DocType: GoCardless Mandate,GoCardless Mandate,GoCardless Mandate
@@ -2790,6 +2801,7 @@
 DocType: Program Enrollment,Self-Driving Vehicle,Samohybné vozidlo
 DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Hodnota karty dodávateľa je stála
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +445,Row {0}: Bill of Materials not found for the Item {1},Riadok {0}: Nomenklatúra nebol nájdený pre výtlačku {1}
+apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +98,Leave Allocations {0} created,Ponechať alokácie {0} vytvorené
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +112,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Celkové pridelené listy {0} nemôže byť nižšia ako už schválených listy {1} pre obdobie
 DocType: Contract Fulfilment Checklist,Requirement,požiadavka
 DocType: Journal Entry,Accounts Receivable,Pohledávky
@@ -2812,7 +2824,6 @@
 DocType: Email Digest,New Expenses,nové výdavky
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +102,PDC/LC Amount,Čiastka PDC / LC
 DocType: Shareholder,Shareholder,akcionár
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Zákaznícka skupina&gt; Územie
 DocType: Purchase Invoice,Additional Discount Amount,Dodatočná zľava Suma
 DocType: Cash Flow Mapper,Position,pozície
 DocType: Patient,Patient Details,Podrobnosti o pacientoch
@@ -2856,14 +2867,14 @@
 apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Nasledujúci materiál žiadosti boli automaticky zvýšená na základe úrovni re-poradie položky
 DocType: Email Digest,Pending Sales Orders,Čaká Predajné objednávky
 apps/erpnext/erpnext/controllers/accounts_controller.py +345,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatná. Mena účtu musí byť {1}
-apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +29,From Date {0} cannot be after employee's relieving Date {1},Od dátumu {0} nemôže byť po uvoľnení zamestnanca Dátum {1}
+apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +31,From Date {0} cannot be after employee's relieving Date {1},Od dátumu {0} nemôže byť po uvoľnení zamestnanca Dátum {1}
 DocType: Supplier,Is Internal Supplier,Je interný dodávateľ
 DocType: Employee,Create User Permission,Vytvoriť povolenie používateľa
 DocType: Employee Benefit Claim,Employee Benefit Claim,Požiadavka na zamestnanecké požitky
 DocType: Healthcare Settings,Remind Before,Pripomenúť predtým
 apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},UOM Konverzní faktor je nutné v řadě {0}
 DocType: Production Plan Item,material_request_item,material_request_item
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1085,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Riadok # {0}: Reference Document Type musí byť jedným zo zákazky odberateľa, predajné faktúry alebo Journal Entry"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1089,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Riadok # {0}: Reference Document Type musí byť jedným zo zákazky odberateľa, predajné faktúry alebo Journal Entry"
 DocType: Salary Component,Deduction,Dedukce
 DocType: Item,Retain Sample,Zachovať ukážku
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Riadok {0}: From Time a na čas je povinná.
@@ -2899,7 +2910,7 @@
 DocType: Work Order Operation,Actual Operation Time,Aktuální Provozní doba
 DocType: Authorization Rule,Applicable To (User),Vztahující se na (Uživatel)
 DocType: Purchase Taxes and Charges,Deduct,Odečíst
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +214,Job Description,Popis Práca
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +219,Job Description,Popis Práca
 DocType: Student Applicant,Applied,aplikovaný
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +879,Re-open,Znovu otevřít
 DocType: Sales Invoice Item,Qty as per Stock UOM,Množstvo podľa skladovej MJ
@@ -2940,7 +2951,6 @@
 DocType: Email Digest,Note: Email will not be sent to disabled users,Poznámka: E-mail nebude odoslaný neaktívnym používateľom
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Počet interakcií
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Počet interakcií
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +169,Supplier &gt; Supplier Type,Dodávateľ&gt; Typ dodávateľa
 apps/erpnext/erpnext/stock/doctype/item/item.js +107,Item Variant Settings,Nastavenia Variantu položky
 apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37,Select Company...,Vyberte spoločnost ...
 DocType: Leave Control Panel,Leave blank if considered for all departments,Nechajte prázdne ak má platiť pre všetky oddelenia
@@ -2989,7 +2999,7 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +396,{0} against Sales Order {1},{0} proti Predajnej Objednávke {1}
 DocType: Account,Fixed Asset,Základní Jmění
 apps/erpnext/erpnext/config/stock.py +328,Serialized Inventory,Serialized Zásoby
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1013,Invalid {0} for Inter Company Invoice.,Neplatná {0} pre faktúru spoločnosti Inter.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1014,Invalid {0} for Inter Company Invoice.,Neplatná {0} pre faktúru spoločnosti Inter.
 ,Department Analytics,Analýza oddelenia
 apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,E-mail sa v predvolenom kontakte nenachádza
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +23,Generate Secret,Generovať tajomstvo
@@ -3016,7 +3026,7 @@
 DocType: Purchase Invoice Item,Weight UOM,Hmotnostná MJ
 apps/erpnext/erpnext/config/accounts.py +478,List of available Shareholders with folio numbers,Zoznam dostupných akcionárov s číslami fotiek
 DocType: Salary Structure Employee,Salary Structure Employee,Plat štruktúra zamestnancov
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +50,Show Variant Attributes,Zobraziť atribúty variantu
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +56,Show Variant Attributes,Zobraziť atribúty variantu
 DocType: Student,Blood Group,Krevní Skupina
 DocType: Course,Course Name,Názov kurzu
 DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Uživatelé, kteří si vyhoví žádosti konkrétního zaměstnance volno"
@@ -3048,7 +3058,7 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,"Prosím, vyberte incharge jméno osoby"
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Technologie
 DocType: Hub Settings,Unregister from Hub,Zrušiť registráciu zo služby Hub
-apps/erpnext/erpnext/public/js/utils.js +108,Total Unpaid: {0},Celkové nezaplatené: {0}
+apps/erpnext/erpnext/public/js/utils.js +109,Total Unpaid: {0},Celkové nezaplatené: {0}
 DocType: BOM Website Operation,BOM Website Operation,BOM Website Operation
 DocType: Bank Statement Transaction Payment Item,outstanding_amount,nesplatená suma
 DocType: Supplier Scorecard,Supplier Score,Skóre dodávateľa
@@ -3057,7 +3067,7 @@
 DocType: BOM,Conversion Rate,Konverzný kurz
 apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Hľadať produkt
 DocType: Assessment Plan,To Time,Chcete-li čas
-apps/erpnext/erpnext/hr/utils.py +189,) for {0},) pre {0}
+apps/erpnext/erpnext/hr/utils.py +201,) for {0},) pre {0}
 DocType: Authorization Rule,Approving Role (above authorized value),Schválenie role (nad oprávnenej hodnoty)
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +134,Credit To account must be a Payable account,Připsat na účet musí být Splatnost účet
 DocType: Loan,Total Amount Paid,Celková čiastka bola zaplatená
@@ -3106,7 +3116,7 @@
 DocType: Fee Schedule Program,Student Batch,študent Batch
 apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Vytvoriť študenta
 DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
-apps/erpnext/erpnext/projects/doctype/project/project.py +218,You have been invited to collaborate on the project: {0},Boli ste pozvaní k spolupráci na projekte: {0}
+apps/erpnext/erpnext/projects/doctype/project/project.py +222,You have been invited to collaborate on the project: {0},Boli ste pozvaní k spolupráci na projekte: {0}
 DocType: Supplier Group,Parent Supplier Group,Rodičovská skupina dodávateľov
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +159,Physician not available on {0},Lekár nie je k dispozícii na {0}
 apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +47,Accumulated Values in Group Company,Akumulované hodnoty v skupine spoločnosti
@@ -3148,7 +3158,7 @@
 apps/erpnext/erpnext/crm/doctype/lead/lead.py +53,Next Contact Date cannot be in the past,Nasledujúce Kontakt dátum nemôže byť v minulosti
 DocType: Company,For Reference Only.,Pouze orientační.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +127,Physician {0} not available on {1},Lekár {0} nie je k dispozícii v {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2586,Select Batch No,Vyberte položku šarže
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2582,Select Batch No,Vyberte položku šarže
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +71,Invalid {0}: {1},Neplatný {0}: {1}
 ,GSTR-1,GSTR-1
 DocType: Purchase Invoice,PINV-RET-,PInv-RET-
@@ -3176,7 +3186,7 @@
 DocType: Item,End of Life,Konec životnosti
 apps/erpnext/erpnext/demo/setup/setup_data.py +325,Travel,Cestování
 DocType: Student Report Generation Tool,Include All Assessment Group,Zahrnúť celú hodnotiacu skupinu
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +227,No active or default Salary Structure found for employee {0} for the given dates,Žiadny aktívny alebo implicitné Plat Štruktúra nájdených pre zamestnancov {0} pre dané termíny
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246,No active or default Salary Structure found for employee {0} for the given dates,Žiadny aktívny alebo implicitné Plat Štruktúra nájdených pre zamestnancov {0} pre dané termíny
 DocType: Leave Block List,Allow Users,Povolit uživatele
 DocType: Purchase Order,Customer Mobile No,Zákazník Mobile Žiadne
 DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Podrobné informácie o šablóne mapovania peňažných tokov
@@ -3200,7 +3210,6 @@
 DocType: Installation Note,Installation Note,Poznámka k instalaci
 DocType: Soil Texture,Clay,hlina
 DocType: Topic,Topic,téma
-apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +20,Please select a leave type to submit the request,"Ak chcete odoslať žiadosť, vyberte typ dovolenky"
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +99,Cash Flow from Financing,Peňažný tok z finančnej
 DocType: Budget Account,Budget Account,rozpočet účtu
 DocType: Quality Inspection,Verified By,Verified By
@@ -3216,7 +3225,7 @@
 DocType: Asset Maintenance Log,Actions performed,Vykonané akcie
 DocType: Cash Flow Mapper,Section Leader,Vedúci sekcie
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +144,Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +35,Source and Target Location cannot be same,Zdroj a cieľové umiestnenie nemôžu byť rovnaké
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +52,Source and Target Location cannot be same,Zdroj a cieľové umiestnenie nemôžu byť rovnaké
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +484,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
 DocType: Supplier Scorecard Scoring Standing,Employee,Zamestnanec
 DocType: Bank Guarantee,Fixed Deposit Number,Číslo s pevným vkladom
@@ -3241,14 +3250,14 @@
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},"Prosím, vyberte BOM pre položku v riadku {0}"
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +13,Fetch Subscription Updates,Načítať aktualizácie odberov
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Účet {0} sa nezhoduje so spoločnosťou {1} v režime účtov: {2}
-apps/erpnext/erpnext/controllers/buying_controller.py +688,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
+apps/erpnext/erpnext/controllers/buying_controller.py +690,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
 apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301,Course: ,Predmet:
 DocType: Soil Texture,Sandy Loam,Sandy Loam
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +238,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí být zrušena před zrušením této prodejní objednávky
 DocType: POS Profile,Applicable for Users,Platí pre používateľov
 DocType: Notification Control,Expense Claim Approved,Uhrazení výdajů schváleno
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Work Orders created,Žiadne pracovné príkazy neboli vytvorené
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +365,Salary Slip of employee {0} already created for this period,Výplatnej páske zamestnanca {0} už vytvorili pre toto obdobie
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +384,Salary Slip of employee {0} already created for this period,Výplatnej páske zamestnanca {0} už vytvorili pre toto obdobie
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +144,Pharmaceutical,Farmaceutické
 apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +24,You can only submit Leave Encashment for a valid encashment amount,Na platnú sumu vkladov môžete odoslať len povolenie na zaplatenie
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Náklady na zakoupené zboží
@@ -3262,7 +3271,7 @@
 DocType: Supplier Scorecard,Warn for new Purchase Orders,Upozornenie na nové nákupné objednávky
 DocType: Quality Inspection Reading,Reading 9,Čtení 9
 DocType: Supplier,Is Frozen,Je Frozen
-apps/erpnext/erpnext/stock/utils.py +224,Group node warehouse is not allowed to select for transactions,Uzol skupina sklad nie je dovolené vybrať pre transakcie
+apps/erpnext/erpnext/stock/utils.py +250,Group node warehouse is not allowed to select for transactions,Uzol skupina sklad nie je dovolené vybrať pre transakcie
 DocType: Buying Settings,Buying Settings,Nastavenie nákupu
 DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce
 DocType: Upload Attendance,Attendance To Date,Účast na data
@@ -3279,7 +3288,7 @@
 DocType: Grant Application,Organization,organizácie
 DocType: BOM Update Tool,BOM Update Tool,Nástroj na aktualizáciu kusovníka
 DocType: SG Creation Tool Course,Student Group Name,Meno Študent Group
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Zobraziť rozložený pohľad
+apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js +23,Show exploded view,Zobraziť rozložený pohľad
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Vytváranie poplatkov
 apps/erpnext/erpnext/setup/doctype/company/company.js +111,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Uistite sa, že naozaj chcete vymazať všetky transakcie pre túto spoločnosť. Vaše kmeňové dáta zostanú, ako to je. Túto akciu nie je možné vrátiť späť."
 apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,Výsledky vyhľadávania
@@ -3372,7 +3381,7 @@
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Schválení Uživatel nemůže být stejná jako uživatel pravidlo se vztahuje na
 DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Základná sadzba (podľa skladovej MJ)
 DocType: SMS Log,No of Requested SMS,Počet žádaným SMS
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +290,Leave Without Pay does not match with approved Leave Application records,Nechať bez nároku na odmenu nesúhlasí so schválenými záznamov nechať aplikáciu
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +309,Leave Without Pay does not match with approved Leave Application records,Nechať bez nároku na odmenu nesúhlasí so schválenými záznamov nechať aplikáciu
 DocType: Campaign,Campaign-.####,Kampaň-.####
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Ďalšie kroky
 DocType: Travel Request,Domestic,domáci
@@ -3464,7 +3473,7 @@
 DocType: Global Defaults,Hide Currency Symbol,Skrýt symbol měny
 apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informácie pre darcu.
 apps/erpnext/erpnext/config/accounts.py +336,"e.g. Bank, Cash, Credit Card","napríkklad banka, hotovosť, kreditné karty"
-DocType: Lead Source,Source Name,Názov zdroja
+DocType: Job Applicant,Source Name,Názov zdroja
 DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normálny pokojový krvný tlak u dospelého pacienta je približne 120 mmHg systolický a diastolický 80 mmHg, skrátený &quot;120/80 mmHg&quot;"
 apps/erpnext/erpnext/stock/doctype/batch/batch.py +124,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Nastavte skladovateľnosť položiek v dňoch, nastavte uplynutie platnosti na základe výrobnej_date a vlastnej životnosti"
 DocType: Journal Entry,Credit Note,Dobropis
@@ -3513,7 +3522,7 @@
 DocType: Buying Settings,Default Buying Price List,Výchozí Nákup Ceník
 DocType: Payroll Entry,Salary Slip Based on Timesheet,Plat Slip na základe časového rozvrhu
 apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +49,Buying Rate,Sadzba nákupu
-apps/erpnext/erpnext/controllers/buying_controller.py +571,Row {0}: Enter location for the asset item {1},Riadok {0}: Zadajte umiestnenie položky majetku {1}
+apps/erpnext/erpnext/controllers/buying_controller.py +573,Row {0}: Enter location for the asset item {1},Riadok {0}: Zadajte umiestnenie položky majetku {1}
 DocType: Notification Control,Sales Order Message,Poznámka predajnej objednávky
 apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Nastavit jako výchozí hodnoty, jako je společnost, měna, aktuálním fiskálním roce, atd"
 DocType: Payment Entry,Payment Type,Typ platby
@@ -3527,7 +3536,7 @@
 DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,Vyhlásenie o oslobodení od dane z príjmu zamestnancov
 DocType: Payment Entry,Cheque/Reference Date,Šek / Referenčný dátum
 DocType: Purchase Invoice,Total Taxes and Charges,Celkem Daně a poplatky
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +78,Available-for-use Date is entered as past date,"Dátum, ktorý je k dispozícii na použitie, je zadaný ako dátum posledného dátumu"
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +89,Available-for-use Date is entered as past date,"Dátum, ktorý je k dispozícii na použitie, je zadaný ako dátum posledného dátumu"
 DocType: Employee,Emergency Contact,Kontakt v nouzi
 DocType: Bank Reconciliation Detail,Payment Entry,platba Entry
 ,sales-browser,Predajná-browser
@@ -3573,6 +3582,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +77,Arrear,nedoplatok
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Odpisy hodnoty v priebehu obdobia
 DocType: Sales Invoice,Is Return (Credit Note),Je návrat (kreditná poznámka)
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +32,Serial no is required for the asset {0},Sériové číslo sa požaduje pre majetok {0}
 apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,Bezbariérový šablóna nesmie byť predvolenú šablónu
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +290,For row {0}: Enter planned qty,Pre riadok {0}: Zadajte naplánované množstvo
 DocType: Shareholder,SH-,SH-
@@ -3589,7 +3599,7 @@
 apps/erpnext/erpnext/setup/doctype/company/company.py +157,Set default inventory account for perpetual inventory,Nastavte predvolený inventárny účet pre trvalý inventár
 DocType: Item Reorder,Material Request Type,Materiál Typ požadavku
 apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Odošlite e-mail na posúdenie grantu
-apps/erpnext/erpnext/accounts/page/pos/pos.js +856,"LocalStorage is full, did not save","Miestne úložisko je plné, nezachránil"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +852,"LocalStorage is full, did not save","Miestne úložisko je plné, nezachránil"
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +113,Row {0}: UOM Conversion Factor is mandatory,Riadok {0}: Konverzný faktor MJ je povinný
 DocType: Employee Benefit Claim,Claim Date,Dátum nároku
 apps/erpnext/erpnext/utilities/user_progress.py +235,Room Capacity,Kapacita miestnosti
@@ -3655,10 +3665,9 @@
 apps/erpnext/erpnext/accounts/party.py +400,{0} {1} is disabled,{0} {1} je zakázaný
 DocType: Supplier,Billing Currency,Mena fakturácie
 DocType: Sales Invoice,SINV-RET-,Sinv-RET-
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +176,Extra Large,Extra Veľké
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +175,Extra Large,Extra Veľké
 DocType: Loan,Loan Application,Aplikácia úveru
 DocType: Crop,Scientific Name,Vedecké meno
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +47,Flexi component require to add max benefit,Komponenty Flexi vyžadujú maximálny prínos
 DocType: Bank Account,Branch Code,Kód pobočky
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +97,Total Leaves,Celkom Listy
 DocType: Customer,"Reselect, if the chosen contact is edited after save","Znova vyberte, ak sa zvolený kontakt upraví po uložení"
@@ -3671,19 +3680,17 @@
 apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Místní
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Úvěrů a půjček (aktiva)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Dlužníci
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +175,Large,Veľký
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +174,Large,Veľký
 DocType: Bank Statement Settings,Bank Statement Settings,Nastavenia bankového výpisu
 DocType: Shopify Settings,Customer Settings,Nastavenia zákazníka
 DocType: Homepage Featured Product,Homepage Featured Product,Úvodná Odporúčané tovar
 apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +12,View Orders,Zobraziť objednávky
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +224,All Assessment Groups,Všetky skupiny Assessment
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +229,All Assessment Groups,Všetky skupiny Assessment
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Nový sklad Name
 DocType: Shopify Settings,App Type,Typ aplikácie
 apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +380,Total {0} ({1}),Celkom {0} ({1})
 DocType: C-Form Invoice Detail,Territory,Území
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +44,"Total flexi component amount {0} should not be less \
-				than max benefits {1}",Celková suma flexi komponentov {0} by nemala byť nižšia ako maximálne výhody {1}
 DocType: Asset,AST,AST
 DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
 apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,poplatok
@@ -3710,8 +3717,8 @@
 apps/erpnext/erpnext/templates/pages/help.html +35,Forum Activity,Aktivita fóra
 ,S.O. No.,SO Ne.
 DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Položka nastavenia transakcie bankového výpisu
-apps/erpnext/erpnext/hr/utils.py +146,To date can not greater than employee's relieving date,K dnešnému dňu nemôže byť väčší ako deň odľahlosti zamestnanca
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Prosím vytvorte Zákazníka z Obchodnej iniciatívy {0}
+apps/erpnext/erpnext/hr/utils.py +158,To date can not greater than employee's relieving date,K dnešnému dňu nemôže byť väčší ako deň odľahlosti zamestnanca
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +242,Please create Customer from Lead {0},Prosím vytvorte Zákazníka z Obchodnej iniciatívy {0}
 apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Vyberte pacienta
 DocType: Price List,Applicable for Countries,Pre krajiny
 DocType: Supplier Scorecard Scoring Variable,Parameter Name,Názov parametra
@@ -3761,7 +3768,7 @@
 DocType: Project,Copied From,Skopírované z
 DocType: Project,Copied From,Skopírované z
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340,Invoice already created for all billing hours,Faktúra už vytvorená pre všetky fakturačné hodiny
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +139,Name error: {0},Názov chyba: {0}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +159,Name error: {0},Názov chyba: {0}
 DocType: Cash Flow Mapping,Is Finance Cost,Sú finančné náklady
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +19,Attendance for employee {0} is already marked,Účast na zaměstnance {0} je již označen
 DocType: Packing Slip,If more than one package of the same type (for print),Pokud je více než jeden balík stejného typu (pro tisk)
@@ -3821,7 +3828,7 @@
 DocType: Bank Statement Transaction Invoice Item,Sales Invoice,Predajná faktúra
 DocType: Journal Entry Account,Party Balance,Balance Party
 DocType: Cash Flow Mapper,Section Subtotal,Oddiel Medzisúčet
-apps/erpnext/erpnext/accounts/page/pos/pos.js +506,Please select Apply Discount On,"Prosím, vyberte Použiť Zľava na"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +502,Please select Apply Discount On,"Prosím, vyberte Použiť Zľava na"
 DocType: Stock Settings,Sample Retention Warehouse,Záznam uchovávania vzoriek
 DocType: Company,Default Receivable Account,Výchozí pohledávek účtu
 DocType: Physician Schedule,Physician Schedule,Plán lekára
@@ -3861,7 +3868,7 @@
 DocType: Attendance Request,Work From Home,Práca z domu
 DocType: Purchase Invoice,Select Supplier Address,Vybrať Dodávateľ Address
 DocType: Purchase Invoice Item,Quality Inspection,Kontrola kvality
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +172,Extra Small,Extra Malé
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +171,Extra Small,Extra Malé
 DocType: Company,Standard Template,štandardná šablóna
 DocType: Training Event,Theory,teória
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +844,Warning: Material Requested Qty is less than Minimum Order Qty,Upozornění: Materiál Požadované množství je menší než minimální objednávka Množství
@@ -3870,7 +3877,7 @@
 DocType: Payment Request,Mute Email,Mute Email
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Potraviny, nápoje a tabák"
 DocType: Account,Account Number,Číslo účtu
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +774,Can only make payment against unbilled {0},Možno vykonať len platbu proti nevyfakturované {0}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +778,Can only make payment against unbilled {0},Možno vykonať len platbu proti nevyfakturované {0}
 apps/erpnext/erpnext/controllers/selling_controller.py +103,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
 DocType: Volunteer,Volunteer,dobrovoľník
 DocType: Buying Settings,Subcontract,Subdodávka
@@ -3888,7 +3895,7 @@
 DocType: Dosage Strength,Dosage Strength,Pevnosť dávkovania
 DocType: Account,Expense Account,Účtet nákladů
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Software
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +179,Colour,Farebné
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +178,Colour,Farebné
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Plan Assessment Criteria
 apps/erpnext/erpnext/stock/doctype/batch/batch.py +123,Expiry date is mandatory for selected item,Dátum vypršania platnosti je pre vybranú položku povinný
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zabráňte nákupným objednávkam
@@ -3911,7 +3918,7 @@
 DocType: Purchase Invoice,Availed ITC Cess,Využil ITC Cess
 ,Student Monthly Attendance Sheet,Študent mesačná návštevnosť Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Pravidlo platia iba pre predaj
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +199,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Odpisový riadok {0}: Nasledujúci Dátum odpisovania nemôže byť pred dátumom nákupu
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +210,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Odpisový riadok {0}: Nasledujúci Dátum odpisovania nemôže byť pred dátumom nákupu
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Datum zahájení projektu
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +36,Until,Dokud
 DocType: Rename Tool,Rename Log,Premenovať Log
@@ -3962,7 +3969,7 @@
 DocType: Employee,You can enter any date manually,Můžete zadat datum ručně
 DocType: Healthcare Settings,Result Printed,Výsledok vytlačený
 DocType: Asset Category Account,Depreciation Expense Account,Odpisy Náklady účtu
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +209,Probationary Period,Skúšobná doba
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +214,Probationary Period,Skúšobná doba
 DocType: Purchase Taxes and Charges Template,Is Inter State,Je Inter State
 apps/erpnext/erpnext/config/hr.py +261,Shift Management,Shift Management
 DocType: Customer Group,Only leaf nodes are allowed in transaction,Pouze koncové uzly jsou povoleny v transakci
@@ -3994,12 +4001,13 @@
 DocType: Supplier Scorecard,Notify Employee,Upozorniť zamestnanca
 DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Zadejte název kampaně, pokud zdroj šetření je kampaň"
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Vydavatelia novín
-apps/erpnext/erpnext/hr/utils.py +142,Future dates not allowed,Budúce termíny nie sú povolené
+apps/erpnext/erpnext/hr/utils.py +154,Future dates not allowed,Budúce termíny nie sú povolené
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Vyberte fiškálny rok
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +117,Expected Delivery Date should be after Sales Order Date,Očakávaný dátum doručenia by mal byť po dátume zákazky predaja
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Změna pořadí Level
 DocType: Company,Chart Of Accounts Template,Účtový rozvrh šablóny
 DocType: Attendance,Attendance Date,Účast Datum
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +80,Update stock must be enable for the purchase invoice {0},Ak chcete aktualizovať nákupnú faktúru {0}
 apps/erpnext/erpnext/stock/get_item_details.py +378,Item Price updated for {0} in Price List {1},Položka Cena aktualizovaný pre {0} v Cenníku {1}
 DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.
 apps/erpnext/erpnext/accounts/doctype/account/account.py +130,Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu
@@ -4054,7 +4062,7 @@
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Období Uzávěrka Entry
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72,Select Department...,Vyberte oddelenie ...
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +40,Cost Center with existing transactions can not be converted to group,Nákladové středisko se stávajícími transakcemi nelze převést do skupiny
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +375,Amount {0} {1} {2} {3},Množstvo {0} {1} {2} {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +376,Amount {0} {1} {2} {3},Množstvo {0} {1} {2} {3}
 DocType: Account,Depreciation,Znehodnocení
 apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +103,The number of shares and the share numbers are inconsistent,Počet akcií a čísla akcií je nekonzistentný
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +50,Supplier(s),Dodavatel (é)
@@ -4088,6 +4096,8 @@
 DocType: Hub Tracked Item,Hub Tracked Item,Pásová sledovaná položka
 DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINÁL PRE PRÍJEMCU
 DocType: Asset Category Account,Accumulated Depreciation Account,účet oprávok
+apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +53,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
+					to cancel this document","Odstráňte zamestnanca <a href=""#Form/Employee/{0}"">{0}</a> \ tento dokument zrušíte"
 DocType: Certified Consultant,Discuss ID,Diskutujte ID
 DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Příspěvky
 DocType: Program Enrollment,Boarding Student,Stravovanie Študent
@@ -4127,7 +4137,7 @@
 apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py +14,Cannot create Retention Bonus for left Employees,Nemožno vytvoriť retenčný bonus pre ľavých zamestnancov
 DocType: Lead,Market Segment,Segment trhu
 DocType: Agriculture Analysis Criteria,Agriculture Manager,Poľnohospodársky manažér
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +964,Paid Amount cannot be greater than total negative outstanding amount {0},Zaplatená suma nemôže byť vyšší ako celkový negatívny dlžnej čiastky {0}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +968,Paid Amount cannot be greater than total negative outstanding amount {0},Zaplatená suma nemôže byť vyšší ako celkový negatívny dlžnej čiastky {0}
 DocType: Supplier Scorecard Period,Variables,Premenné
 DocType: Employee Internal Work History,Employee Internal Work History,Interní historie práce zaměstnance
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249,Closing (Dr),Uzavření (Dr)
@@ -4147,7 +4157,6 @@
 DocType: Sales Invoice Item,Available Qty at Warehouse,Množství k dispozici na skladu
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Fakturovaná čiastka
 DocType: Share Transfer,(including),(počítajúc do toho)
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte pomenovanie série {0} cez Nastavenie&gt; Nastavenia&gt; Pomenovanie série
 DocType: Asset,Double Declining Balance,double degresívne
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +184,Closed order cannot be cancelled. Unclose to cancel.,Uzavretá objednávka nemôže byť zrušený. Otvoriť zrušiť.
 apps/erpnext/erpnext/config/hr.py +120,Payroll Setup,Nastavenie miezd
@@ -4193,7 +4202,7 @@
 apps/erpnext/erpnext/config/stock.py +113,Serial No and Batch,Sériové číslo a Dávka
 DocType: Warranty Claim,From Company,Od Společnosti
 apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52,Sum of Scores of Assessment Criteria needs to be {0}.,Súčet skóre hodnotiacich kritérií musí byť {0}.
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +187,Please set Number of Depreciations Booked,Prosím nastavte Počet Odpisy rezervované
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +198,Please set Number of Depreciations Booked,Prosím nastavte Počet Odpisy rezervované
 DocType: Supplier Scorecard Period,Calculations,výpočty
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86,Value or Qty,Hodnota nebo Množství
 DocType: Payment Terms Template,Payment Terms,Platobné podmienky
@@ -4205,14 +4214,14 @@
 apps/erpnext/erpnext/utilities/user_progress.py +121,Go to Suppliers,Prejdite na dodávateľov
 DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,Dane z kupónového uzávierky POS
 ,Qty to Receive,Množství pro příjem
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +514,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Dátumy začiatku a ukončenia, ktoré nie sú v platnom mzdovom období, nemožno vypočítať {0}."
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +533,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.","Dátumy začiatku a ukončenia, ktoré nie sú v platnom mzdovom období, nemožno vypočítať {0}."
 DocType: Leave Block List,Leave Block List Allowed,Nechte Block List povolena
 DocType: Grading Scale Interval,Grading Scale Interval,Stupnica Interval
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Náklady Nárok na Vehicle Log {0}
 DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Zľava (%) na sadzbe cien s maržou
 DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Zľava (%) na sadzbe cien s maržou
 apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,všetky Sklady
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1143,No {0} found for Inter Company Transactions.,Nie je {0} zistené pre transakcie medzi spoločnosťami.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1144,No {0} found for Inter Company Transactions.,Nie je {0} zistené pre transakcie medzi spoločnosťami.
 DocType: Travel Itinerary,Rented Car,Nájomné auto
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +131,Credit To account must be a Balance Sheet account,Pripísať na účet musí byť účtu Súvaha
 DocType: Donor,Donor,darcu
@@ -4306,7 +4315,7 @@
 DocType: Student Group,Group Based On,Skupina založená na
 DocType: Journal Entry,Bill Date,Bill Datum
 DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratórne SMS upozornenia
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +229,Creating Bank Entries......,Vytváranie bankoviek ......
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +234,Creating Bank Entries......,Vytváranie bankoviek ......
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","je nutný servisný položky, typ, frekvencia a množstvo náklady"
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","I když existuje více pravidla pro tvorbu cen s nejvyšší prioritou, pak následující interní priority jsou použity:"
 DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kritériá analýzy rastlín
@@ -4319,6 +4328,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +158,Wire Transfer,Bankovní převod
 apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,"skontrolujte, či všetky"
 ,Issued Items Against Work Order,Vydané položky proti pracovnému príkazu
+,BOM Stock Calculated,Výpočet zásob BOM
 DocType: Vehicle Log,Invoice Ref,faktúra Ref
 DocType: Company,Default Income Account,Účet Default příjmů
 apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Zákazník Group / Customer
@@ -4346,6 +4356,7 @@
 DocType: Purchase Order Item Supplied,Stock UOM,Skladová MJ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +249,Purchase Order {0} is not submitted,Vydaná objednávka {0} nie je odoslaná
 DocType: Account,Expenses Included In Asset Valuation,Náklady zahrnuté do ocenenia majetku
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte pomenovanie série {0} cez Nastavenie&gt; Nastavenia&gt; Pomenovanie série
 DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normálny referenčný rozsah pre dospelého je 16-20 dych / minúta (RCP 2012)
 DocType: Customs Tariff Number,Tariff Number,tarif Počet
 DocType: Work Order Item,Available Qty at WIP Warehouse,Dostupné množstvo v WIP Warehouse
@@ -4381,7 +4392,6 @@
 DocType: Purchase Invoice,Return Against Purchase Invoice,Návrat proti nákupnej faktúry
 DocType: Item,Warranty Period (in days),Záruční doba (ve dnech)
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Failed to set defaults,Nepodarilo sa nastaviť predvolené hodnoty
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,"Prosím, nastavte názov inštruktora systému vo vzdelávaní&gt; Nastavenia vzdelávania"
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Súvislosť s Guardian1
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +795,Please select BOM against item {0},"Prosím, vyberte položku BOM proti položke {0}"
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Vykonajte faktúry
@@ -4395,7 +4405,7 @@
 DocType: Shopping Cart Settings,Quotation Series,Číselná rada ponúk
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57,"An item exists with same name ({0}), please change the item group name or rename the item","Položka s rovnakým názvom už existuje ({0}), prosím, zmente názov skupiny položiek alebo premenujte položku"
 DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kritériá analýzy pôdy
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2046,Please select customer,vyberte zákazníka
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2042,Please select customer,vyberte zákazníka
 DocType: C-Form,I,ja
 DocType: Company,Asset Depreciation Cost Center,Asset Odpisy nákladového strediska
 DocType: Production Plan Sales Order,Sales Order Date,Dátum predajnej objednávky
@@ -4565,13 +4575,14 @@
 DocType: Account,Rate at which this tax is applied,"Rychlost, při které se používá tato daň"
 DocType: Cash Flow Mapper,Section Name,Názov sekcie
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +79,Reorder Qty,Změna pořadí Množství
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +272,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Riadok odpisov {0}: Očakávaná hodnota po uplynutí životnosti musí byť väčšia alebo rovná {1}
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +283,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},Riadok odpisov {0}: Očakávaná hodnota po uplynutí životnosti musí byť väčšia alebo rovná {1}
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +55,Current Job Openings,Aktuálne pracovné príležitosti
 DocType: Company,Stock Adjustment Account,Reklamní Nastavení účtu
 apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Odpísať
 DocType: Healthcare Service Unit,Allow Overlap,Povoliť prekrytie
 DocType: Timesheet Detail,Operation ID,Prevádzka ID
 DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","System User (login) ID. Pokud je nastaveno, stane se výchozí pro všechny formy HR."
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +86,Enter depreciation details,Zadajte podrobnosti o odpisoch
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Z {1}
 DocType: Task,depends_on,záleží na
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Naliehavá aktualizácia najnovšej ceny vo všetkých účtovných dokladoch. Môže to trvať niekoľko minút.
@@ -4608,7 +4619,7 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +582,Please select Posting Date before selecting Party,"Prosím, vyberte Dátum zverejnenia pred výberom Party"
 DocType: Program Enrollment,School House,School House
 DocType: Serial No,Out of AMC,Out of AMC
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +192,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet Odpisy rezervované nemôže byť väčšia ako celkový počet Odpisy
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +203,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet Odpisy rezervované nemôže byť väčšia ako celkový počet Odpisy
 DocType: Purchase Order,Order Confirmation Date,Dátum potvrdenia objednávky
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Proveďte návštěv údržby
 DocType: Employee Transfer,Employee Transfer Details,Podrobnosti o zamestnancovi
@@ -4665,7 +4676,7 @@
 DocType: Employee Benefit Application,Payroll Period,Mzdové obdobie
 DocType: Plant Analysis,Plant Analysis Criterias,Kritériá analýzy rastlín
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +237,Serial No {0} does not belong to Batch {1},Sériové číslo {0} nepatrí do dávky {1}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +215,Responsibilities,Zodpovednosť
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +220,Responsibilities,Zodpovednosť
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Platnosť tejto ponuky sa skončila.
 DocType: Expense Claim Account,Expense Claim Account,Náklady na poistné Account
 DocType: Account,Capital Work in Progress,Kapitálová práca prebieha
@@ -4693,6 +4704,7 @@
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +131,Debit Note Amount,Výška dlžnej sumy
 DocType: Project Update,Not Updated,Neaktualizované
 apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +107,"There are inconsistencies between the rate, no of shares and the amount calculated","Existujú nezrovnalosti medzi sadzbou, počtom akcií a vypočítanou sumou"
+apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +39,You are not present all day(s) between compensatory leave request days,Nie ste prítomní celý deň (dni) medzi náhradnými dovolenkovými dňami
 apps/erpnext/erpnext/setup/doctype/company/company.js +109,Please re-type company name to confirm,Prosím re-typ názov spoločnosti na potvrdenie
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +234,Total Outstanding Amt,Celkem Vynikající Amt
 DocType: Journal Entry,Printing Settings,Nastavenie tlače
@@ -4748,7 +4760,7 @@
 DocType: Material Request Item,For Warehouse,Pro Sklad
 DocType: Employee,Offer Date,Dátum Ponuky
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Ponuky
-apps/erpnext/erpnext/accounts/page/pos/pos.js +743,You are in offline mode. You will not be able to reload until you have network.,"Ste v režime offline. Nebudete môcť znovu, kým nebudete mať sieť."
+apps/erpnext/erpnext/accounts/page/pos/pos.js +739,You are in offline mode. You will not be able to reload until you have network.,"Ste v režime offline. Nebudete môcť znovu, kým nebudete mať sieť."
 DocType: Leave Period,Grant,grant
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Žiadne študentské skupiny vytvorený.
 DocType: Purchase Invoice Item,Serial No,Výrobní číslo
@@ -4760,7 +4772,7 @@
 DocType: Sales Invoice,Customer PO Details,Podrobnosti PO zákazníka
 DocType: Stock Entry,Including items for sub assemblies,Vrátane položiek pre montážnych podskupín
 DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Dočasný úvodný účet
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1973,Enter value must be positive,Zadajte hodnota musí byť kladná
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1969,Enter value must be positive,Zadajte hodnota musí byť kladná
 DocType: Asset,Finance Books,Finančné knihy
 DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Vyhlásenie o oslobodení od dane zamestnancov
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +448,All Territories,Všetky územia
@@ -4770,7 +4782,7 @@
 apps/erpnext/erpnext/crm/doctype/contract/contract.py +38,End Date cannot be before Start Date.,Dátum ukončenia nemôže byť pred dátumom začiatku.
 apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,Student is already enrolled.,Študent je už zapísané.
 DocType: Fiscal Year,Year Name,Meno roku
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +285,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +304,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +101,PDC/LC Ref,PDC / LC Ref
 DocType: Production Plan Item,Product Bundle Item,Položka produktového balíčka
 DocType: Sales Partner,Sales Partner Name,Meno predajného partnera
@@ -4828,8 +4840,8 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +56,Plants and Machineries,Rastliny a strojné vybavenie
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po slevě Částka
 DocType: Daily Work Summary Settings,Daily Work Summary Settings,Každodennú prácu Súhrnné Nastavenie
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1138,Selected Price List should have buying and selling fields checked.,Vybraný cenník by mal kontrolovať pole nákupu a predaja.
-apps/erpnext/erpnext/controllers/buying_controller.py +663,Please enter Reqd by Date,Zadajte Reqd podľa dátumu
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1139,Selected Price List should have buying and selling fields checked.,Vybraný cenník by mal kontrolovať pole nákupu a predaja.
+apps/erpnext/erpnext/controllers/buying_controller.py +664,Please enter Reqd by Date,Zadajte Reqd podľa dátumu
 DocType: Payment Entry,Internal Transfer,vnútorné Prevod
 DocType: Asset Maintenance,Maintenance Tasks,Úlohy údržby
 apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Buď cílové množství nebo cílová částka je povinná
@@ -4943,14 +4955,16 @@
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +217,Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
 DocType: BOM,Website Description,Popis webu
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +101,Net Change in Equity,Čistá zmena vo vlastnom imaní
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +280,Please cancel Purchase Invoice {0} first,Zrušte faktúre {0} prvý
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +291,Please cancel Purchase Invoice {0} first,Zrušte faktúre {0} prvý
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-mailová adresa musí byť jedinečná, už existuje pre {0}"
 DocType: Serial No,AMC Expiry Date,AMC Datum vypršení platnosti
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Group,Dodávateľ&gt; Skupina dodávateľov
 DocType: Asset,Receipt,príjem
 ,Sales Register,Sales Register
 DocType: Daily Work Summary Group,Send Emails At,Posielať e-maily At
 DocType: Quotation,Quotation Lost Reason,Dôvod neúspešnej ponuky
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +382,Transaction reference no {0} dated {1},Referenčné transakcie no {0} z {1}
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položiek&gt; Značka
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +383,Transaction reference no {0} dated {1},Referenčné transakcie no {0} z {1}
 apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js +5,There is nothing to edit.,Není nic upravovat.
 apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +499,Form View,Zobrazenie formulára
 DocType: HR Settings,Expense Approver Mandatory In Expense Claim,Povinnosť priraďovania nákladov v nárokoch na výdavky
@@ -5013,6 +5027,7 @@
 DocType: Subscription Settings,Grace Period,Doba odkladu
 DocType: Item Alternative,Alternative Item Name,Alternatívny názov položky
 apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Parent Item {0} nesmie byť skladom
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +187,Website Listing,Výpis webových stránok
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +485,"Could not submit any Salary Slip <br>\
 			Possible reasons: <br>\
 			1. Net pay is less than 0. <br>\
@@ -5020,7 +5035,7 @@
 apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Všechny výrobky nebo služby.
 DocType: Expense Claim,More Details,Další podrobnosti
 DocType: Supplier Quotation,Supplier Address,Dodavatel Address
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +157,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Rozpočet na účet {1} proti {2} {3} je {4}. To bude presahovať o {5}
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +160,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Rozpočet na účet {1} proti {2} {3} je {4}. To bude presahovať o {5}
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Out Množství
 apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +49,Series is mandatory,Série je povinné
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Finanční služby
@@ -5091,7 +5106,7 @@
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +814,Send Supplier Emails,Poslať Dodávateľ e-maily
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +172,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plat už spracované pre obdobie medzi {0} a {1}, ponechajte dobu použiteľnosti nemôže byť medzi tomto časovom období."
 DocType: Fiscal Year,Auto Created,Automatické vytvorenie
-apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +18,Submit this to create the Employee record,"Odošlite toto, aby ste vytvorili záznam zamestnanca"
+apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py +19,Submit this to create the Employee record,"Odošlite toto, aby ste vytvorili záznam zamestnanca"
 DocType: Item Default,Item Default,Položka Predvolená
 DocType: Chapter Member,Leave Reason,Nechajte dôvod
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +203,Invoice {0} no longer exists,Faktúra {0} už neexistuje
@@ -5105,7 +5120,7 @@
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,ID e-mailu Guardian1
 DocType: Lab Prescription,Test Code,Testovací kód
 apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Nastavenie titulnej stránky webu
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +873,{0} is on hold till {1},{0} je pozastavená do {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +877,{0} is on hold till {1},{0} je pozastavená do {1}
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ nie sú povolené pre {0} kvôli postaveniu skóre {1}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +9,Used Leaves,Použité listy
 DocType: Job Offer,Awaiting Response,Čaká odpoveď
@@ -5195,8 +5210,6 @@
 apps/erpnext/erpnext/controllers/accounts_controller.py +659,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Riadok # {0}: Asset {1} nemôže byť predložený, je už {2}"
 DocType: Tax Rule,Billing Country,Fakturačná krajina
 DocType: Purchase Order Item,Expected Delivery Date,Očekávané datum dodání
-apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py +53,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
-					to cancel this document","Odstráňte zamestnanca <a href=""#Form/Employee/{0}"">{0}</a> \ tento dokument zrušíte"
 DocType: Restaurant Order Entry,Restaurant Order Entry,Vstup do objednávky reštaurácie
 apps/erpnext/erpnext/accounts/general_ledger.py +134,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetné a kreditné nerovná za {0} # {1}. Rozdiel je v tom {2}.
 DocType: Budget,Control Action,Kontrolná akcia
@@ -5262,7 +5275,7 @@
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Podriadené uzly môžu byť vytvorené len na základe typu uzly &quot;skupina&quot;
 DocType: Attendance Request,Half Day Date,Half Day Date
 DocType: Academic Year,Academic Year Name,Akademický rok Meno
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1022,{0} not allowed to transact with {1}. Please change the Company.,{0} nesmie transakcie s {1}. Zmeňte spoločnosť.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1023,{0} not allowed to transact with {1}. Please change the Company.,{0} nesmie transakcie s {1}. Zmeňte spoločnosť.
 DocType: Sales Partner,Contact Desc,Kontakt Popis
 DocType: Email Digest,Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy e-mailem.
 DocType: Payment Entry,PE-,PE
@@ -5293,7 +5306,7 @@
 DocType: Hotel Room,Hotel Manager,Hotelový manažér
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Sada Daňové Pravidlo pre nákupného košíka
 DocType: Purchase Invoice,Taxes and Charges Added,Daně a poplatky přidané
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +203,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Odpisový riadok {0}: Nasledujúci dátum odpisovania nemôže byť pred dátumom k dispozícii na použitie
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +214,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,Odpisový riadok {0}: Nasledujúci dátum odpisovania nemôže byť pred dátumom k dispozícii na použitie
 ,Sales Funnel,Predajný lievik
 apps/erpnext/erpnext/setup/doctype/company/company.py +53,Abbreviation is mandatory,Skratka je povinná
 DocType: Project,Task Progress,pokrok úloha
@@ -5305,7 +5318,7 @@
 DocType: Stock Settings,Role Allowed to edit frozen stock,Role povoleno upravovat zmrazené zásoby
 ,Territory Target Variance Item Group-Wise,Území Cílová Odchylka Item Group-Wise
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,All Customer Groups,Všechny skupiny zákazníků
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +144,Accumulated Monthly,nahromadené za mesiac
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +147,Accumulated Monthly,nahromadené za mesiac
 DocType: Attendance Request,On Duty,V službe
 apps/erpnext/erpnext/controllers/accounts_controller.py +813,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možno nie je vytvorený záznam Zmeny meny pre {1} až {2}.
 apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +51,Staffing Plan {0} already exist for designation {1},Personálny plán {0} už existuje pre označenie {1}
@@ -5327,7 +5340,7 @@
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +29,This action will stop future billing. Are you sure you want to cancel this subscription?,Táto akcia zastaví budúcu fakturáciu. Naozaj chcete zrušiť tento odber?
 DocType: Serial No,Distinct unit of an Item,Samostatnou jednotku z položky
 DocType: Supplier Scorecard Criteria,Criteria Name,Názov kritéria
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1319,Please set Company,Nastavte spoločnosť
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1329,Please set Company,Nastavte spoločnosť
 DocType: Pricing Rule,Buying,Nákupy
 apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Choroby a hnojivá
 DocType: HR Settings,Employee Records to be created by,Zamestnanecké záznamy na vytvorenie kým
@@ -5437,6 +5450,7 @@
 DocType: Depreciation Schedule,Accumulated Depreciation Amount,oprávky Suma
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity
 DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Premenná ukazovateľa tabuľky dodávateľov
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +75,Please create purchase receipt or purchase invoice for the item {0},Vytvorte doklad o kúpe alebo nákupnú faktúru pre položku {0}
 DocType: Employee Advance,Due Advance Amount,Splatná výška zálohy
 DocType: Maintenance Visit,Customer Feedback,Zpětná vazba od zákazníků
 DocType: Account,Expense,Výdaj
@@ -5446,9 +5460,9 @@
 DocType: Item Attribute,From Range,Od Rozsah
 DocType: BOM,Set rate of sub-assembly item based on BOM,Nastavte rýchlosť položky podsúboru na základe kusovníka
 DocType: Hotel Room Reservation,Invoiced,fakturovaná
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +141,Syntax error in formula or condition: {0},syntaktická chyba vo vzorci alebo stave: {0}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +161,Syntax error in formula or condition: {0},syntaktická chyba vo vzorci alebo stave: {0}
 DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Každodennú prácu Súhrnné Nastavenie Company
-apps/erpnext/erpnext/stock/utils.py +125,Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem"
+apps/erpnext/erpnext/stock/utils.py +151,Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem"
 DocType: Appraisal,APRSL,APRSL
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Nechcete-li použít Ceník článek v dané transakce, by měly být všechny platné pravidla pro tvorbu cen zakázáno."
 DocType: Payment Term,Day(s) after the end of the invoice month,Deň (dni) po skončení fakturačného mesiaca
@@ -5479,6 +5493,7 @@
 ,Delivery Note Trends,Dodací list Trendy
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +114,This Week's Summary,Tento týždeň Zhrnutie
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Na sklade Množstvo
+,Daily Work Summary Replies,Denné zhrnutie pracovných odpovedí
 DocType: Delivery Trip,Calculate Estimated Arrival Times,Vypočítajte odhadované časy príchodu
 apps/erpnext/erpnext/accounts/general_ledger.py +113,Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím Skladových Transakcí
 DocType: Student Group Creation Tool,Get Courses,získať kurzy
@@ -5486,7 +5501,7 @@
 DocType: Bank Statement Transaction Invoice Item,Party,Strana
 DocType: Healthcare Settings,Patient Name,Názov pacienta
 DocType: Variant Field,Variant Field,Variantné pole
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +335,Target Location,Miesto zacielenia
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +341,Target Location,Miesto zacielenia
 DocType: Sales Order,Delivery Date,Dodávka Datum
 DocType: Opportunity,Opportunity Date,Příležitost Datum
 DocType: Employee,Health Insurance Provider,Poskytovateľ zdravotného poistenia
@@ -5525,13 +5540,14 @@
 DocType: Loan,Rate of Interest (%) / Year,Úroková sadzba (%) / rok
 ,Project Quantity,projekt Množstvo
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Total {0} u všetkých položiek je nulová, môže byť by ste mali zmeniť, Distribuovať poplatkov na základe &#39;"
-apps/erpnext/erpnext/hr/utils.py +140,To date can not be less than from date,K dnešnému dňu nemôže byť menej ako od dátumu
+apps/erpnext/erpnext/hr/utils.py +152,To date can not be less than from date,K dnešnému dňu nemôže byť menej ako od dátumu
 DocType: Opportunity,To Discuss,K projednání
 apps/erpnext/erpnext/stock/stock_ledger.py +377,{0} units of {1} needed in {2} to complete this transaction.,{0} jednotiek {1} potrebná {2} pre dokončenie tejto transakcie.
 DocType: Loan Type,Rate of Interest (%) Yearly,Úroková sadzba (%) Ročné
 DocType: Support Settings,Forum URL,Adresa URL fóra
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +75,Temporary Accounts,Dočasné Účty
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +183,Black,Čierna
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +40,Source Location is required for the asset {0},Umiestnenie zdroja sa vyžaduje pre majetok {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Black,Čierna
 DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Item
 DocType: Shareholder,Contact List,Zoznam kontaktov
 DocType: Account,Auditor,Auditor
@@ -5553,6 +5569,7 @@
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Cheques Required,Potrebné kontroly
 DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku)
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Označiť ako neprítomný
+DocType: Job Applicant Source,Job Applicant Source,Zdroj žiadateľa o zamestnanie
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Nepodarilo sa nastaviť spoločnosť
 DocType: Asset Repair,Asset Repair,Oprava majetku
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Riadok {0}: Mena BOM # {1} by sa mala rovnať vybranej mene {2}
@@ -5598,9 +5615,9 @@
 DocType: Leave Policy Detail,Leave Policy Detail,Zanechať podrobnosti o pravidlách
 apps/erpnext/erpnext/public/js/hub/hub_form.js +381,Suggest Category,Navrhnúť kategóriu
 DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
-apps/erpnext/erpnext/accounts/page/pos/pos.js +903,Submitted orders can not be deleted,Predložené objednávky nemožno zmazať
+apps/erpnext/erpnext/accounts/page/pos/pos.js +899,Submitted orders can not be deleted,Predložené objednávky nemožno zmazať
 apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +320,Quality Management,Řízení kvality
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +325,Quality Management,Řízení kvality
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +52,Item {0} has been disabled,Item {0} bol zakázaný
 DocType: Project,Total Billable Amount (via Timesheets),Celková fakturovaná suma (prostredníctvom dochádzky)
 DocType: Agriculture Task,Previous Business Day,Predchádzajúci pracovný deň
@@ -5629,7 +5646,7 @@
 DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Povoliť sadzbu nulového oceňovania
 DocType: Bank Guarantee,Receiving,príjem
 DocType: Training Event Employee,Invited,pozvaný
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +222,Multiple active Salary Structures found for employee {0} for the given dates,Viac aktívny Plat Structures nájdených pre zamestnancov {0} pre dané termíny
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241,Multiple active Salary Structures found for employee {0} for the given dates,Viac aktívny Plat Structures nájdených pre zamestnancov {0} pre dané termíny
 apps/erpnext/erpnext/config/accounts.py +314,Setup Gateway accounts.,Nastavenia brány účty.
 DocType: Employee,Employment Type,Typ zaměstnání
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Fixed Assets,Dlouhodobý majetek
@@ -5645,7 +5662,7 @@
 DocType: Tax Rule,Sales Tax Template,Daň z predaja Template
 DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,Platba proti nároku na dávku
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +21,Update Cost Center Number,Aktualizovať číslo Centra nákladov
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2515,Select items to save the invoice,"Vyberte položky, ktoré chcete uložiť faktúru"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2511,Select items to save the invoice,"Vyberte položky, ktoré chcete uložiť faktúru"
 DocType: Employee,Encashment Date,Inkaso Datum
 DocType: Training Event,Internet,internet
 DocType: Special Test Template,Special Test Template,Špeciálna šablóna testu
@@ -5684,7 +5701,7 @@
 DocType: Tax Withholding Category,Threshold,Prah
 DocType: BOM Update Tool,Current BOM,Aktuální BOM
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32,Balance (Dr - Cr),Zostatok (Dr - Cr)
-apps/erpnext/erpnext/public/js/utils.js +55,Add Serial No,Přidat Sériové číslo
+apps/erpnext/erpnext/public/js/utils.js +56,Add Serial No,Přidat Sériové číslo
 DocType: Work Order Item,Available Qty at Source Warehouse,Dostupné množstvo v zdrojovom sklade
 apps/erpnext/erpnext/config/support.py +22,Warranty,záruka
 DocType: Purchase Invoice,Debit Note Issued,vydanie dlhopisu
@@ -5696,6 +5713,7 @@
 DocType: Workstation,per hour,za hodinu
 DocType: Blanket Order,Purchasing,nákup
 DocType: Announcement,Announcement,oznámenia
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +25,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosím, nastavte systém pomenovania zamestnancov v oblasti ľudských zdrojov&gt; Nastavenia personálu"
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +107,Customer LPO,Zákazník LPO
 DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",V prípade dávkovej študentskej skupiny bude študentská dávka schválená pre každého študenta zo zápisu do programu.
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse nelze vypustit, neboť existuje zásob, kniha pro tento sklad."
@@ -5707,7 +5725,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +121,Project Manager,Project Manager
 ,Quoted Item Comparison,Citoval Položka Porovnanie
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Prekrývajúci sa bodovanie medzi {0} a {1}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +316,Dispatch,Odeslání
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +321,Dispatch,Odeslání
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +75,Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Čistá hodnota aktív aj na
 DocType: Crop,Produce,vyrobiť
@@ -5719,7 +5737,7 @@
 DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Role, která se nechá podat transakcí, které přesahují úvěrové limity."
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1009,Select Items to Manufacture,Vyberte položky do výroby
 DocType: Delivery Stop,Delivery Stop,Zastavenie doručenia
-apps/erpnext/erpnext/accounts/page/pos/pos.js +971,"Master data syncing, it might take some time","Kmeňové dáta synchronizácia, môže to trvať nejaký čas"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +967,"Master data syncing, it might take some time","Kmeňové dáta synchronizácia, môže to trvať nejaký čas"
 DocType: Item,Material Issue,Material Issue
 DocType: Employee Education,Qualification,Kvalifikace
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,View Salary Slips,Zobraziť výplatné platy
@@ -5738,7 +5756,8 @@
 DocType: Healthcare Settings,Patient Name By,Názov pacienta
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +256,Accrual Journal Entry for salaries from {0} to {1},Záznam o účtovaní časového rozlíšenia pre platy od {0} do {1}
 DocType: Sales Invoice Item,Enable Deferred Revenue,Povoliť odložené výnosy
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +182,Opening Accumulated Depreciation must be less than equal to {0},Otvorenie Oprávky musí byť menšia ako rovná {0}
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +193,Opening Accumulated Depreciation must be less than equal to {0},Otvorenie Oprávky musí byť menšia ako rovná {0}
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Prosím, nastavte číselnú sériu pre účasť v programe Setup&gt; Numbering Series"
 DocType: Warehouse,Warehouse Name,Název Skladu
 DocType: Naming Series,Select Transaction,Vybrat Transaction
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel
@@ -5753,6 +5772,7 @@
 DocType: Leave Block List,Applies to Company,Platí pre firmu
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +240,Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože předložena Reklamní Entry {0} existuje"
 DocType: Loan,Disbursement Date,vyplatenie Date
+apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py +23,Reply Count,Počet odpovedí
 DocType: BOM Update Tool,Update latest price in all BOMs,Aktualizujte najnovšiu cenu vo všetkých kusovníkoch
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23,Medical Record,Zdravotný záznam
 DocType: Vehicle,Vehicle,vozidlo
@@ -5775,12 +5795,12 @@
 DocType: Material Request,MREQ-,MREQ-
 DocType: Payment Schedule,Invoice Portion,Časť faktúry
 ,Asset Depreciations and Balances,Asset Odpisy a zostatkov
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +371,Amount {0} {1} transferred from {2} to {3},Množstvo {0} {1} prevedená z {2} na {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +372,Amount {0} {1} transferred from {2} to {3},Množstvo {0} {1} prevedená z {2} na {3}
 DocType: Sales Invoice,Get Advances Received,Získat přijaté zálohy
 DocType: Email Digest,Add/Remove Recipients,Přidat / Odebrat příjemce
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Chcete-li nastavit tento fiskální rok jako výchozí, klikněte na tlačítko ""Nastavit jako výchozí"""
 DocType: Production Plan,Include Subcontracted Items,Zahrňte subdodávateľné položky
-apps/erpnext/erpnext/projects/doctype/project/project.py +220,Join,pripojiť
+apps/erpnext/erpnext/projects/doctype/project/project.py +224,Join,pripojiť
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Nedostatek Množství
 apps/erpnext/erpnext/stock/doctype/item/item.py +737,Item variant {0} exists with same attributes,Variant Položky {0} existuje s rovnakými vlastnosťami
 DocType: Loan,Repay from Salary,Splatiť z platu
@@ -5803,6 +5823,7 @@
 DocType: Accounts Settings,Stale Days,Stale dni
 DocType: Travel Itinerary,Arrival Datetime,Dátum príchodu
 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.","Když některý z kontrolovaných operací je ""Odesláno"", email pop-up automaticky otevřeny poslat e-mail na přidružené ""Kontakt"" v této transakci, s transakcí jako přílohu. Uživatel může, ale nemusí odeslat e-mail."
+DocType: Tax Rule,Billing Zipcode,Fakturačný PSČ
 apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globálne nastavenia
 DocType: Crop,Row Spacing UOM,Rozloženie riadkov UOM
 DocType: Assessment Result Detail,Assessment Result Detail,Posúdenie Detail Výsledok
@@ -5820,7 +5841,7 @@
 DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,Vytvorte samostatné zadanie platby pred nárokom na dávku
 DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Prítomnosť horúčky (teplota&gt; 38,5 ° C alebo udržiavaná teplota&gt; 38 ° C / 100,4 ° F)"
 DocType: Customer,Sales Team Details,Podrobnosti prodejní tým
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1360,Delete permanently?,Zmazať trvalo?
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1356,Delete permanently?,Zmazať trvalo?
 DocType: Expense Claim,Total Claimed Amount,Celkem žalované částky
 apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potenciální příležitosti pro prodej.
 DocType: Shareholder,Folio no.,Folio č.
@@ -5877,9 +5898,9 @@
 DocType: Item Attribute Value,Attribute Value,Hodnota atributu
 DocType: POS Closing Voucher Details,Expected Amount,Očakávaná suma
 ,Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level
-apps/erpnext/erpnext/hr/utils.py +199,Employee {0} of grade {1} have no default leave policy,Zamestnanec {0} v platovej triede {1} nemá žiadne predvolené pravidlá pre dovolenku
+apps/erpnext/erpnext/hr/utils.py +211,Employee {0} of grade {1} have no default leave policy,Zamestnanec {0} v platovej triede {1} nemá žiadne predvolené pravidlá pre dovolenku
 DocType: Salary Detail,Salary Detail,plat Detail
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,Please select {0} first,"Prosím, najprv vyberte {0}"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1072,Please select {0} first,"Prosím, najprv vyberte {0}"
 DocType: Appointment Type,Physician,lekár
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1026,Batch {0} of Item {1} has expired.,Batch {0} z {1} bodu vypršala.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,konzultácie
@@ -5934,7 +5955,6 @@
 apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: You can not assign itself as parent account,Účet {0}: nelze přiřadit sebe jako nadřazený účet
 DocType: Purchase Invoice Item,Price List Rate,Cenníková cena
 apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Vytvoriť zákaznícke ponuky
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Group,Dodávateľ&gt; Skupina dodávateľov
 DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Zobrazit ""Skladem"" nebo ""Není skladem"" na základě skladem k dispozici v tomto skladu."
 apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Bill of Materials (BOM)
 DocType: Item,Average time taken by the supplier to deliver,Priemerná doba zhotovená dodávateľom dodať
@@ -5963,7 +5983,7 @@
 apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Hotovo
 DocType: Employee,Educational Qualification,Vzdělávací Kvalifikace
 DocType: Workstation,Operating Costs,Provozní náklady
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483,Currency for {0} must be {1},Mena pre {0} musí byť {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +484,Currency for {0} must be {1},Mena pre {0} musí byť {1}
 DocType: Asset,Disposal Date,Likvidácia Dátum
 DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","E-maily budú zaslané všetkým aktívnym zamestnancom spoločnosti v danú hodinu, ak nemajú dovolenku. Zhrnutie odpovedí budú zaslané do polnoci."
 DocType: Employee Leave Approver,Employee Leave Approver,Schvalujúci priepustiek zamestnanca
@@ -6009,7 +6029,8 @@
 apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js +91,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Postup skladovania k dispozícii nie je v sklade. Chcete zaznamenať prevod akcií
 DocType: Shipping Rule,Shipping Rule Type,Typ pravidla odoslania
 apps/erpnext/erpnext/utilities/user_progress.py +239,Go to Rooms,Prejdite na Izby
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +232,"Company, Payment Account, From Date and To Date is mandatory","Spoločnosť, platobný účet, dátum a dátum je povinný"
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +237,"Company, Payment Account, From Date and To Date is mandatory","Spoločnosť, platobný účet, dátum a dátum je povinný"
+DocType: Company,Budget Detail,Detail Rozpočtu
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,"Prosím, zadejte zprávu před odesláním"
 DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLIKÁT PRE DODÁVATEĽA
 DocType: Email Digest,Pending Quotations,Čakajúce ponuky
@@ -6036,14 +6057,14 @@
 DocType: Naming Series,Help HTML,Nápoveda HTML
 DocType: Student Group Creation Tool,Student Group Creation Tool,Študent Group Tool Creation
 DocType: Item,Variant Based On,Variant založená na
-apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +60,Employee {0} already have Leave Allocation {1} for this period,Zamestnanec {0} už má pre toto obdobie ponechať pridelenie {1}
+apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +71,Employee {0} already have Leave Allocation {1} for this period,Zamestnanec {0} už má pre toto obdobie ponechať pridelenie {1}
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Celková weightage přiřazen by měla být 100%. Je {0}
 apps/erpnext/erpnext/utilities/user_progress.py +109,Your Suppliers,Vaši Dodávatelia
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,"Nelze nastavit jako Ztraceno, protože je přijata objednávka."
 DocType: Request for Quotation Item,Supplier Part No,Žiadny dodávateľ Part
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +384,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nemôže odpočítať, ak kategória je pre &quot;ocenenie&quot; alebo &quot;Vaulation a Total&quot;"
 apps/erpnext/erpnext/public/js/hub/hub_form.js +197,Anonymous,anonymný
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +378,Received From,Prijaté Od
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Received From,Prijaté Od
 DocType: Lead,Converted,Převedené
 DocType: Item,Has Serial No,Má Sériové číslo
 DocType: Employee,Date of Issue,Datum vydání
@@ -6102,7 +6123,7 @@
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Počet dnů od poslední objednávky
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +370,Debit To account must be a Balance Sheet account,Debetné Na účet musí byť účtu Súvaha
 DocType: Asset,Naming Series,Číselné rady
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +170,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Riadok {0}: Očakávaná hodnota po skončení životnosti musí byť nižšia ako čiastka hrubého nákupu
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +181,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,Riadok {0}: Očakávaná hodnota po skončení životnosti musí byť nižšia ako čiastka hrubého nákupu
 DocType: GoCardless Settings,GoCardless Settings,Nastavenia GoCardless
 DocType: Leave Block List,Leave Block List Name,Nechte Jméno Block List
 DocType: Certified Consultant,Certification Validity,Platnosť certifikátu
@@ -6117,7 +6138,7 @@
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Delivery Note {0} nesmí být předloženy
 DocType: Notification Control,Sales Invoice Message,Prodejní faktury Message
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Záverečný účet {0} musí byť typu zodpovednosti / Equity
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +369,Salary Slip of employee {0} already created for time sheet {1},Výplatnej páske zamestnanca {0} už vytvorili pre časové list {1}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +388,Salary Slip of employee {0} already created for time sheet {1},Výplatnej páske zamestnanca {0} už vytvorili pre časové list {1}
 DocType: Vehicle Log,Odometer,Počítadlo najazdených kilometrov
 DocType: Production Plan Item,Ordered Qty,Objednáno Množství
 apps/erpnext/erpnext/stock/doctype/item/item.py +767,Item {0} is disabled,Položka {0} je zakázaná
@@ -6125,6 +6146,7 @@
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +979,BOM does not contain any stock item,BOM neobsahuje žiadnu skladovú položku
 DocType: Chapter,Chapter Head,Kapitola hlavu
 DocType: Payment Term,Month(s) after the end of the invoice month,Mesiac (mesiace) po skončení mesiaca faktúry
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +47,Salary Structure should have flexible benefit component(s) to dispense benefit amount,Štruktúra platu by mala mať flexibilné zložky prínosov na vyplácanie dávky
 apps/erpnext/erpnext/config/projects.py +24,Project activity / task.,Projektová činnost / úkol.
 DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),"Iba daňový vplyv (nemožno nárokovať, ale časť zdaniteľného príjmu)"
 DocType: Vehicle Log,Refuelling Details,tankovacie Podrobnosti
@@ -6159,7 +6181,7 @@
 DocType: Employee External Work History,Salary,Plat
 DocType: Serial No,Delivery Document Type,Dodávka Typ dokumentu
 DocType: Sales Order,Partly Delivered,Částečně vyhlášeno
-apps/erpnext/erpnext/hr/utils.py +201,Employee {0} has no grade to get default leave policy,"Zamestnanec {0} nemá žiadnu platovú triedu na to, aby získal predvolené pravidlá pre dovolenku"
+apps/erpnext/erpnext/hr/utils.py +213,Employee {0} has no grade to get default leave policy,"Zamestnanec {0} nemá žiadnu platovú triedu na to, aby získal predvolené pravidlá pre dovolenku"
 DocType: Item Variant Settings,Do not update variants on save,Neaktualizujte varianty uloženia
 DocType: Email Digest,Receivables,Pohledávky
 DocType: Lead Source,Lead Source,Zdroj Iniciatívy
@@ -6203,12 +6225,12 @@
 DocType: Products Settings,Home Page is Products,Domovskou stránkou je stránka Produkty.
 ,Asset Depreciation Ledger,Asset Odpisy Ledger
 DocType: Salary Structure,Leave Encashment Amount Per Day,Ponechajte sumu zaplatenia za deň
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91,Tax Rule Conflicts with {0},Daňové Pravidlo Konflikty s {0}
+apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +95,Tax Rule Conflicts with {0},Daňové Pravidlo Konflikty s {0}
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Nový názov účtu
 DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Dodává se nákladů na suroviny
 DocType: Selling Settings,Settings for Selling Module,Nastavenie modulu Predaj
 DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervácia izieb v hoteli
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +317,Customer Service,Služby zákazníkům
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +322,Customer Service,Služby zákazníkům
 DocType: BOM,Thumbnail,Thumbnail
 DocType: Item Customer Detail,Item Customer Detail,Položka Detail Zákazník
 DocType: Notification Control,Prompt for Email on Submission of,Výzva pro e-mail na předkládání
@@ -6287,7 +6309,7 @@
 apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informácie o dárcovom type.
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +60,Available for use date is required,Je potrebný dátum použiteľného na použitie
 DocType: Request for Quotation,Supplier Detail,Detail dodávateľa
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +143,Error in formula or condition: {0},Chyba vo vzorci alebo stave: {0}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +163,Error in formula or condition: {0},Chyba vo vzorci alebo stave: {0}
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +112,Invoiced Amount,Fakturovaná čiastka
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Kritériové váhy musia pripočítať až 100%
 apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Účast
@@ -6306,7 +6328,6 @@
 apps/erpnext/erpnext/config/selling.py +67,Price List master.,Ceník master.
 DocType: Task,Review Date,Review Datum
 DocType: BOM,Allow Alternative Item,Povoliť alternatívnu položku
-apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +82,Leave Allocation {0} created,Písmeno Allocation {0} bolo vytvorené
 DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Séria pre odpisy majetku (záznam v účte)
 DocType: Membership,Member Since,Členom od
 DocType: Purchase Invoice,Advance Payments,Zálohové platby
@@ -6321,11 +6342,12 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +100,Administrative Expenses,Administrativní náklady
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Consulting
 DocType: Customer Group,Parent Customer Group,Parent Customer Group
+DocType: Vehicle Service,Change,Zmena
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +848,Subscription,predplatné
 DocType: Purchase Invoice,Contact Email,Kontaktní e-mail
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Tvorba poplatkov čaká
 DocType: Appraisal Goal,Score Earned,Skóre Zasloužené
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +217,Notice Period,Výpovedná Lehota
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +222,Notice Period,Výpovedná Lehota
 DocType: Asset Category,Asset Category Name,Asset názov kategórie
 apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,To je kořen území a nelze upravovat.
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Meno Nová Sales Osoba
@@ -6447,7 +6469,7 @@
 ,Items To Be Requested,Položky se budou vyžadovat
 DocType: Purchase Order,Get Last Purchase Rate,Získejte posledního nákupu Cena
 DocType: Company,Company Info,Informácie o spoločnosti
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1393,Select or add new customer,Vyberte alebo pridajte nového zákazníka
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1389,Select or add new customer,Vyberte alebo pridajte nového zákazníka
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +177,Cost center is required to book an expense claim,Nákladové stredisko je nutné rezervovať výdavkov nárok
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Aplikace fondů (aktiv)
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,To je založené na účasti základu tohto zamestnanca
@@ -6489,10 +6511,10 @@
 DocType: Quality Inspection Reading,Reading 3,Čtení 3
 DocType: Stock Entry,Source Warehouse Address,Adresa zdrojového skladu
 DocType: GL Entry,Voucher Type,Voucher Type
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1725,Price List not found or disabled,Ceník nebyl nalezen nebo zakázán
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1721,Price List not found or disabled,Ceník nebyl nalezen nebo zakázán
 DocType: Student Applicant,Approved,Schválený
 apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,Cena
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +311,Employee relieved on {0} must be set as 'Left',"Zamestnanec uvoľnený na {0} musí byť nastavený ako ""Opustil"""
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +330,Employee relieved on {0} must be set as 'Left',"Zamestnanec uvoľnený na {0} musí byť nastavený ako ""Opustil"""
 DocType: Hub Settings,Last Sync On,Posledná synchronizácia zapnutá
 DocType: Guardian,Guardian,poručník
 DocType: Item Alternative,Item Alternative,Položka Alternatíva
@@ -6518,7 +6540,7 @@
 apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py +52,Attendance not submitted for {0} as it is a Holiday.,"Účasť sa nepredložila za {0}, pretože ide o dovolenku."
 DocType: POS Profile,Account for Change Amount,Účet pre zmenu Suma
 DocType: Exchange Rate Revaluation,Total Gain/Loss,Celkový zisk / strata
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1015,Invalid Company for Inter Company Invoice.,Neplatná spoločnosť pre faktúru medzi spoločnosťami.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1016,Invalid Company for Inter Company Invoice.,Neplatná spoločnosť pre faktúru medzi spoločnosťami.
 DocType: Purchase Invoice,input service,vstupná služba
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +249,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Riadok {0}: Party / Account nezhoduje s {1} / {2} do {3} {4}
 DocType: Employee Promotion,Employee Promotion,Podpora zamestnancov
@@ -6527,7 +6549,7 @@
 apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13,Course Code: ,Kód kurzu:
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,Please enter Expense Account,"Prosím, zadejte výdajového účtu"
 DocType: Account,Stock,Sklad
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1093,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Riadok # {0}: Reference Document Type musí byť jedným z objednávky, faktúry alebo Journal Entry"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1097,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Riadok # {0}: Reference Document Type musí byť jedným z objednávky, faktúry alebo Journal Entry"
 DocType: Employee,Current Address,Aktuálna 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","Je-li položka je varianta další položku pak popis, obraz, oceňování, daní atd bude stanoven ze šablony, pokud není výslovně uvedeno"
 DocType: Serial No,Purchase / Manufacture Details,Nákup / Výroba Podrobnosti
@@ -6549,6 +6571,7 @@
 DocType: Production Plan Item,Planned Qty,Plánované Množství
 DocType: Company,Date of Incorporation,Dátum začlenenia
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total Tax
+apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +40,Last Purchase Price,Posledná nákupná cena
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +246,For Quantity (Manufactured Qty) is mandatory,Pre Množstvo (Vyrobené ks) je povinné
 DocType: Stock Entry,Default Target Warehouse,Výchozí Target Warehouse
 DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Company Měna)
@@ -6575,18 +6598,18 @@
 apps/erpnext/erpnext/config/stock.py +145,Fulfilment,splnenie
 DocType: Purchase Taxes and Charges,On Previous Row Amount,Na předchozí řady Částka
 DocType: Item,Has Expiry Date,Má dátum skončenia platnosti
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +332,Transfer Asset,prevod majetku
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +338,Transfer Asset,prevod majetku
 DocType: POS Profile,POS Profile,POS Profile
 DocType: Training Event,Event Name,Názov udalosti
 DocType: Physician,Phone (Office),Telefón (Office)
-apps/erpnext/erpnext/controllers/buying_controller.py +738,"Following item {items} {verb} not marked as {message} item.\
+apps/erpnext/erpnext/controllers/buying_controller.py +740,"Following item {items} {verb} not marked as {message} item.\
 			You can enable them as {message} item from its Item master","Nasledujúca položka {items} {verb}, ktorá nebola označená ako položka {message}. Môžete ich povoliť ako položku {message} z jej položky Master"
 apps/erpnext/erpnext/hooks.py +151,Admission,vstupné
 apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Prijímacie konanie pre {0}
 apps/erpnext/erpnext/config/accounts.py +263,"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
 DocType: Supplier Scorecard Scoring Variable,Variable Name,Názov premennej
 apps/erpnext/erpnext/stock/get_item_details.py +154,"Item {0} is a template, please select one of its variants","Položka {0} je šablóna, prosím vyberte jednu z jeho variantov"
-apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +24,From Date {0} cannot be before employee's joining Date {1},Od dátumu {0} nemôže byť pred dátumom spájania zamestnanca {1}
+apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +26,From Date {0} cannot be before employee's joining Date {1},Od dátumu {0} nemôže byť pred dátumom spájania zamestnanca {1}
 DocType: Asset,Asset Category,asset Kategórie
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +20,Net pay cannot be negative,Netto plat nemôže byť záporný
 DocType: Purchase Order,Advance Paid,Vyplacené zálohy
@@ -6615,9 +6638,11 @@
 DocType: Scheduling Tool,Scheduling Tool,plánovanie Tool
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +156,Credit Card,Kreditní karta
 DocType: BOM,Item to be manufactured or repacked,Položka být vyráběn nebo znovu zabalena
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +734,Syntax error in condition: {0},Chyba syntaxe v stave: {0}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +781,Syntax error in condition: {0},Chyba syntaxe v stave: {0}
 DocType: Employee Education,Major/Optional Subjects,Hlavní / Volitelné předměty
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125,Please Set Supplier Group in Buying Settings.,Nastavte skupinu dodávateľov v nastaveniach nákupu.
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +44,"Total flexible benefit component amount {0} should not be less \
+				than max benefits {1}",Celková suma zložky flexibilného prínosu {0} by nemala byť nižšia ako maximálne prínosy {1}
 DocType: Sales Invoice Item,Drop Ship,Drop Loď
 DocType: Driver,Suspended,suspendovaný
 DocType: Training Event,Attendees,Účastníci
@@ -6652,7 +6677,7 @@
 DocType: Manufacturing Settings,Allow Production on Holidays,Povolit Výrobu při dovolené
 DocType: Sales Invoice,Customer's Purchase Order Date,Zákazníka Objednávka Datum
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +173,Capital Stock,Základný kapitál
-DocType: Company,Default Finance Book,Predvolená kniha financií
+DocType: Asset,Default Finance Book,Predvolená kniha financií
 DocType: Shopping Cart Settings,Show Public Attachments,Zobraziť verejné prílohy
 DocType: Packing Slip,Package Weight Details,Hmotnost balení Podrobnosti
 DocType: Leave Type,Is Compensatory,Je kompenzačný
@@ -6662,15 +6687,15 @@
 DocType: Company,Existing Company,existujúce Company
 DocType: Healthcare Settings,Result Emailed,Výsledok bol odoslaný e-mailom
 apps/erpnext/erpnext/controllers/buying_controller.py +92,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Daňová kategória bola zmenená na &quot;Celkom&quot;, pretože všetky položky sú položky, ktoré nie sú na sklade"
-apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +65,To date can not be equal or less than from date,K dnešnému dňu nemôže byť rovnaká alebo menšia ako od dátumu
+apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py +76,To date can not be equal or less than from date,K dnešnému dňu nemôže byť rovnaká alebo menšia ako od dátumu
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +118,Nothing to change,Nič sa nemenia
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Vyberte soubor csv
 DocType: Student Leave Application,Mark as Present,Označiť ako prítomný
 DocType: Supplier Scorecard,Indicator Color,Farba indikátora
 DocType: Purchase Order,To Receive and Bill,Prijímať a Bill
-apps/erpnext/erpnext/controllers/buying_controller.py +661,Row #{0}: Reqd by Date cannot be before Transaction Date,Riadok # {0}: Reqd by Date nemôže byť pred dátumom transakcie
+apps/erpnext/erpnext/controllers/buying_controller.py +662,Row #{0}: Reqd by Date cannot be before Transaction Date,Riadok # {0}: Reqd by Date nemôže byť pred dátumom transakcie
 apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Predstavované produkty
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +349,Select Serial No,Vyberte položku Sériové číslo
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +355,Select Serial No,Vyberte položku Sériové číslo
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Designer,Návrhář
 apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Podmínky Template
 DocType: Serial No,Delivery Details,Zasílání
@@ -6688,7 +6713,6 @@
 DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Neukazovať žiadny symbol ako $ atď vedľa meny.
 apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +86,Maximum benefit amount of component {0} exceeds {1},Maximálna výška dávky komponentu {0} presahuje {1}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +536, (Half Day),(Pól dňa)
-apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +61,Active Salary Structure Assignment {0} found for employee {1} for the given dates,Aktívna štruktúra platovej štruktúry {0} bola nájdená pre zamestnanca {1} pre dané dátumy
 DocType: Payment Term,Credit Days,Úvěrové dny
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145,Please select Patient to get Lab Tests,"Ak chcete získať laboratórne testy, vyberte položku Pacient"
 apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Urobiť Študent Batch
