diff --git a/erpnext/translations/sk.csv b/erpnext/translations/sk.csv
index 8c076f8..72b6322 100644
--- a/erpnext/translations/sk.csv
+++ b/erpnext/translations/sk.csv
@@ -1,33 +1,31 @@
 DocType: Employee,Salary Mode,Mode Plat
-DocType: Cost Center,"Select Monthly Distribution, if you want to track based on seasonality.","Vyberte měsíční výplatou, pokud chcete sledovat na základě sezónnosti."
 DocType: Employee,Divorced,Rozvedený
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +81,Warning: Same item has been entered multiple times.,Upozornenie: Rovnaké položky bol zadaný viackrát.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +84,Warning: Same item has been entered multiple times.,Upozornenie: Rovnaké položky bol zadaný viackrát.
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +96,Items already synced,Položky již synchronizovat
 DocType: Buying Settings,Allow Item to be added multiple times in a transaction,"Povoliť položky, ktoré sa pridávajú viackrát v transakcii"
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Materiál Navštivte {0} před zrušením této záruční reklamaci Zrušit
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +19,Consumer Products,Spotřební zboží
+apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +19,Consumer Products,Zákaznícke produkty
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +68,Please select Party Type first,"Prosím, vyberte typ Party prvý"
 DocType: Item,Customer Items,Zákazník položky
 DocType: Project,Costing and Billing,Kalkulácia a fakturácia
-apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Účet {0}: Nadřazený účet {1} nemůže být hlavní kniha
+apps/erpnext/erpnext/accounts/doctype/account/account.py +52,Account {0}: Parent account {1} can not be a ledger,Účet {0}: Nadřazený účet {1} nemůže být hlavní kniha
 DocType: Item,Publish Item to hub.erpnext.com,Publikování položku do hub.erpnext.com
-apps/erpnext/erpnext/config/setup.py +93,Email Notifications,E-mailová upozornění
+apps/erpnext/erpnext/config/setup.py +88,Email Notifications,E-mailová upozornění
 DocType: Item,Default Unit of Measure,Predvolená merná jednotka
 DocType: SMS Center,All Sales Partner Contact,Všechny Partneři Kontakt
 DocType: Employee,Leave Approvers,Nechte schvalovatelů
 DocType: Sales Partner,Dealer,Dealer
 DocType: Employee,Rented,Pronajato
 DocType: POS Profile,Applicable for User,Použiteľné pre Užívateľa
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +173,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Zastavil výrobu Objednať nemožno zrušiť, uvoľniť ho najprv zrušiť"
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +35,Do you really want to scrap this asset?,Naozaj chcete zrušiť túto pohľadávku?
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Zastavil výrobu Objednať nemožno zrušiť, uvoľniť ho najprv zrušiť"
+apps/erpnext/erpnext/accounts/doctype/asset/asset.js +197,Do you really want to scrap this asset?,Naozaj chcete zrušiť túto pohľadávku?
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +36,Currency is required for Price List {0},Měna je vyžadováno pro Ceníku {0}
 DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bude vypočítané v transakcii.
 DocType: Purchase Order,Customer Contact,Zákaznícky kontakt
-apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +37,{0} Tree,{0} Strom
 DocType: Job Applicant,Job Applicant,Job Žadatel
 apps/erpnext/erpnext/hub_node/page/hub/hub_body.html +18,No more results.,Žádné další výsledky.
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +34,Legal,Právní
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +114,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}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +130,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: C-Form,Customer,Zákazník
 DocType: Purchase Receipt Item,Required By,Vyžadováno
 DocType: Delivery Note,Return Against Delivery Note,Návrat Proti dodací list
@@ -35,38 +33,36 @@
 DocType: Purchase Order,% Billed,% Fakturovaných
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Exchange Rate musí byť rovnaká ako {0} {1} ({2})
 DocType: Sales Invoice,Customer Name,Meno zákazníka
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +100,Bank account cannot be named as {0},Bankový účet nemôže byť menovaný ako {0}
-DocType: Features Setup,"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Všech oblastech souvisejících vývozní jako měnu, přepočítacího koeficientu, export celkem, export celkovém součtu etc jsou k dispozici v dodací list, POS, citace, prodejní faktury, prodejní objednávky atd"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +124,Bank account cannot be named as {0},Bankový účet nemôže byť menovaný ako {0}
 DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Heads (nebo skupiny), proti nimž účetní zápisy jsou vyrobeny a stav je veden."
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +176,Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1})
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +180,Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1})
 DocType: Manufacturing Settings,Default 10 mins,Predvolené 10 min
 DocType: Leave Type,Leave Type Name,Nechte Typ Jméno
-apps/erpnext/erpnext/templates/pages/projects.js +81,Show open,ukázať otvorené
+apps/erpnext/erpnext/templates/pages/projects.js +63,Show open,ukázať otvorené
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +148,Series Updated Successfully,Řada Aktualizováno Úspěšně
 DocType: Pricing Rule,Apply On,Naneste na
 DocType: Item Price,Multiple Item prices.,Více ceny položku.
 ,Purchase Order Items To Be Received,Položky vydané objednávky k přijetí
 DocType: SMS Center,All Supplier Contact,Vše Dodavatel Kontakt
 DocType: Quality Inspection Reading,Parameter,Parametr
-apps/erpnext/erpnext/projects/doctype/project/project.py +44,Expected End Date can not be less than Expected Start Date,"Očakávané Dátum ukončenia nemôže byť nižšia, než sa očakávalo dáta začatia"
+apps/erpnext/erpnext/projects/doctype/project/project.py +52,Expected End Date can not be less than Expected Start Date,"Očakávané Dátum ukončenia nemôže byť nižšia, než sa očakávalo dáta začatia"
 apps/erpnext/erpnext/utilities/transaction_base.py +107,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Riadok # {0}: Cena musí byť rovnaké, ako {1}: {2} ({3} / {4})"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +229,New Leave Application,New Leave Application
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +134,Bank Draft,Bank Návrh
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +142,Bank Draft,Bank Návrh
 DocType: Mode of Payment Account,Mode of Payment Account,Způsob platby účtu
-apps/erpnext/erpnext/stock/doctype/item/item.js +49,Show Variants,Zobraziť Varianty
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +515,Quantity,Množství
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +504,Accounts table cannot be blank.,Účty tabuľka nemôže byť prázdne.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +177,Loans (Liabilities),Úvěry (závazky)
+apps/erpnext/erpnext/stock/doctype/item/item.js +52,Show Variants,Zobraziť Varianty
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +584,Quantity,Množství
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +511,Accounts table cannot be blank.,Účty tabuľka nemôže byť prázdne.
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +151,Loans (Liabilities),Úvěry (závazky)
 DocType: Employee Education,Year of Passing,Rok Passing
 apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock,Na skladě
 DocType: Designation,Designation,Označení
 DocType: Production Plan Item,Production Plan Item,Výrobní program Item
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +146,User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1}
-apps/erpnext/erpnext/accounts/page/pos/pos_page.html +13,Make new POS Profile,Vykonajte nové POS profil
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +142,User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1}
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +31,Health Care,Péče o zdraví
 DocType: Purchase Invoice,Monthly,Měsíčně
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +66,Delay in payment (Days),Oneskorenie s platbou (dni)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +645,Invoice,Faktúra
+apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Oneskorenie s platbou (dni)
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +718,Invoice,Faktúra
 DocType: Maintenance Schedule Item,Periodicity,Periodicita
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Fiškálny rok {0} je vyžadovaná
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +21,Defense,Obrana
@@ -75,42 +71,36 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +198,Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} se neshoduje s {3}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +74,Row # {0}:,Řádek # {0}:
 DocType: Delivery Note,Vehicle No,Vozidle
-apps/erpnext/erpnext/public/js/pos/pos.js +557,Please select Price List,"Prosím, vyberte Ceník"
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +127,Please select Price List,"Prosím, vyberte Ceník"
 DocType: Production Order Operation,Work In Progress,Work in Progress
 DocType: Employee,Holiday List,Dovolená Seznam
-DocType: Time Log,Time Log,Time Log
-apps/erpnext/erpnext/public/js/setup_wizard.js +180,Accountant,Účtovník
+apps/erpnext/erpnext/public/js/setup_wizard.js +205,Accountant,Účtovník
 DocType: Cost Center,Stock User,Sklad Užívateľ
 DocType: Company,Phone No,Telefon
-DocType: Time Log,"Log of Activities performed by users against Tasks that can be used for tracking time, billing.","Log činností vykonávaných uživateli proti úkoly, které mohou být použity pro sledování času, fakturaci."
 apps/erpnext/erpnext/controllers/recurring_document.py +132,New {0}: #{1},Nový {0}: # {1}
 ,Sales Partners Commission,Obchodní partneři Komise
 apps/erpnext/erpnext/setup/doctype/company/company.py +38,Abbreviation cannot have more than 5 characters,Zkratka nesmí mít více než 5 znaků
 DocType: Payment Request,Payment Request,Platba Dopyt
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +56,"Attribute Value {0} cannot be removed from {1} as Item Variants \
-						exist with this Attribute.",Atribút Hodnota {0} nemôže byť odstránený z {1} ako položka Varianty \ existovať tohto atribútu.
-apps/erpnext/erpnext/accounts/doctype/account/account.js +27,This is a root account and cannot be edited.,To je kořen účtu a nelze upravovat.
+apps/erpnext/erpnext/accounts/doctype/account/account.js +26,This is a root account and cannot be edited.,To je kořen účtu a nelze upravovat.
 DocType: BOM,Operations,Operace
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Nelze nastavit oprávnění na základě Sleva pro {0}
 DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Pripojiť CSV súbor s dvomi stĺpci, jeden pre starý názov a jeden pre nový názov"
 DocType: Packed Item,Parent Detail docname,Parent Detail docname
-apps/erpnext/erpnext/public/js/setup_wizard.js +272,Kg,Kg
+apps/erpnext/erpnext/public/js/setup_wizard.js +298,Kg,Kg
 apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Otevření o zaměstnání.
 DocType: Item Attribute,Increment,Prírastok
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +39,PayPal Settings missing,PayPal Nastavenie chýbajúce
-apps/erpnext/erpnext/public/js/stock_analytics.js +63,Select Warehouse...,Vyberte Warehouse ...
+apps/erpnext/erpnext/public/js/stock_analytics.js +62,Select Warehouse...,Vyberte Warehouse ...
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +6,Advertising,Reklama
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Rovnaký Spoločnosť je zapísaná viac ako raz
 DocType: Employee,Married,Ženatý
 apps/erpnext/erpnext/accounts/party.py +38,Not permitted for {0},Nepovolené pre {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +441,Get items from,Získať predmety z
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +390,Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +536,Get items from,Získať predmety z
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +377,Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
 DocType: Payment Reconciliation,Reconcile,Srovnat
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,Potraviny
 DocType: Quality Inspection Reading,Reading 1,Čtení 1
 DocType: Process Payroll,Make Bank Entry,Proveďte Bank Vstup
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +40,Pension Funds,Penzijní fondy
-apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Warehouse is mandatory if account type is Warehouse,"Sklad je povinné, pokud typ účtu je Warehouse"
 DocType: SMS Center,All Sales Person,Všichni obchodní zástupci
 DocType: Lead,Person Name,Osoba Meno
 DocType: Sales Invoice Item,Sales Invoice Item,Prodejní faktuře položka
@@ -118,9 +108,9 @@
 DocType: POS Profile,Write Off Cost Center,Odepsat nákladové středisko
 apps/erpnext/erpnext/config/stock.py +32,Stock Reports,stock Reports
 DocType: Warehouse,Warehouse Detail,Sklad Detail
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +181,Credit limit has been crossed for customer {0} {1}/{2},Úvěrový limit byla překročena o zákazníka {0} {1} / {2}
-DocType: Tax Rule,Tax Type,Daňové Type
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +140,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +156,Credit limit has been crossed for customer {0} {1}/{2},Úvěrový limit byla překročena o zákazníka {0} {1} / {2}
+DocType: Tax Rule,Tax Type,Typ dane
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +144,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: Item,Item Image (if not slideshow),Item Image (ne-li slideshow)
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,An Customer exists with same name,Zákazník existuje se stejným názvem
 DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hodina Rate / 60) * Skutočná Prevádzková doba
@@ -129,76 +119,68 @@
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Dovolenka na {0} nie je medzi Dátum od a do dnešného dňa
 DocType: Quality Inspection,Get Specification Details,Získat Specifikace Podrobnosti
 DocType: Lead,Interested,Zájemci
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +158,Opening,Otvor
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +162,Opening,Otvor
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +27,From {0} to {1},Od {0} do {1}
 DocType: Item,Copy From Item Group,Kopírovat z bodu Group
 DocType: Journal Entry,Opening Entry,Otevření Entry
 DocType: Stock Entry,Additional Costs,Dodatočné náklady
-apps/erpnext/erpnext/accounts/doctype/account/account.py +137,Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +141,Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.
 DocType: Lead,Product Enquiry,Dotaz Product
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +13,Please enter company first,"Prosím, nejprave zadejte společnost"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +324,Please select Company first,"Prosím, vyberte první firma"
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,"Prosím, nejprave zadejte společnost"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +335,Please select Company first,"Prosím, vyberte první firma"
 DocType: Employee Education,Under Graduate,Za absolventa
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Target On
 DocType: BOM,Total Cost,Celkové náklady
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +9,Activity Log:,Aktivita Log:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +206,Item {0} does not exist in the system or has expired,Bod {0} neexistuje v systému nebo vypršela
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204,Item {0} does not exist in the system or has expired,Bod {0} neexistuje v systému nebo vypršela
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +44,Real Estate,Nemovitost
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +4,Statement of Account,Výpis z účtu
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +41,Pharmaceuticals,Farmaceutické
-DocType: Item,Is Fixed Asset,Je dlhodobého majetku
+DocType: Purchase Invoice Item,Is Fixed Asset,Je dlhodobého majetku
 DocType: Expense Claim Detail,Claim Amount,Nárok Částka
 DocType: Employee,Mr,Pan
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +33,Supplier Type / Supplier,Dodavatel Typ / dovozce
 DocType: Naming Series,Prefix,Prefix
-apps/erpnext/erpnext/public/js/setup_wizard.js +269,Consumable,Spotřební
+apps/erpnext/erpnext/public/js/setup_wizard.js +295,Consumable,Spotrebný materiál
 DocType: Upload Attendance,Import Log,Záznam importu
 DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Vytiahnite Materiál Žiadosť typu Výroba na základe vyššie uvedených kritérií
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.js +19,Send,Odeslat
 DocType: Sales Invoice Item,Delivered By Supplier,Dodáva sa podľa dodávateľa
 DocType: SMS Center,All Contact,Vše Kontakt
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +164,Annual Salary,Ročné Plat
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +173,Annual Salary,Ročné Plat
 DocType: Period Closing Voucher,Closing Fiscal Year,Uzavření fiskálního roku
-apps/erpnext/erpnext/accounts/party.py +326,{0} {1} is frozen,{0} {1} je zmrazený
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Stock Expenses,Stock Náklady
-DocType: Newsletter,Email Sent?,E-mail odeslán?
+apps/erpnext/erpnext/accounts/party.py +349,{0} {1} is frozen,{0} {1} je zmrazený
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +78,Stock Expenses,Stock Náklady
 DocType: Journal Entry,Contra Entry,Contra Entry
-DocType: Production Order Operation,Show Time Logs,Show Time Záznamy
 DocType: Journal Entry Account,Credit in Company Currency,Úverové spoločnosti v mene
 DocType: Delivery Note,Installation Status,Stav instalace
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +108,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +316,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0}
 DocType: Item,Supply Raw Materials for Purchase,Dodávky suroviny pre nákup
-apps/erpnext/erpnext/stock/get_item_details.py +139,Item {0} must be a Purchase Item,Bod {0} musí být Nákup položky
 DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
 All dates and employee combination in the selected period will come in the template, with existing attendance records","Stáhněte si šablony, vyplňte potřebné údaje a přiložte upravený soubor.
  Všechny termíny a zaměstnanec kombinaci ve zvoleném období přijde v šabloně, se stávajícími evidence docházky"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +446,Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
-DocType: Time Log Batch,Will be updated after Sales Invoice is Submitted.,Bude aktualizováno po odeslání faktury.
-apps/erpnext/erpnext/controllers/accounts_controller.py +533,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Chcete-li zahrnout daně na řádku v poměru Položka {0}, daně v řádcích {1} musí být zahrnuty"
-apps/erpnext/erpnext/config/hr.py +170,Settings for HR Module,Nastavenie modulu HR
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +451,Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
+apps/erpnext/erpnext/controllers/accounts_controller.py +614,"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"
+apps/erpnext/erpnext/config/hr.py +166,Settings for HR Module,Nastavenie modulu HR
 DocType: SMS Center,SMS Center,SMS centrum
 DocType: BOM Replace Tool,New BOM,New BOM
-apps/erpnext/erpnext/config/projects.py +40,Batch Time Logs for billing.,Batch čas Záznamy pro fakturaci.
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +30,Newsletter has already been sent,Newsletter bol už odoslaný
+DocType: Timesheet,Batch Time Logs for billing.,Batch čas Záznamy pro fakturaci.
 DocType: Lead,Request Type,Typ požadavku
 DocType: Leave Application,Reason,Důvod
 apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +15,Make Employee,urobiť zamestnanca
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +14,Broadcasting,Vysílání
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +140,Execution,Provedení
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +149,Execution,Provedení
 apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Podrobnosti o prováděných operací.
 DocType: Serial No,Maintenance Status,Status Maintenance
-apps/erpnext/erpnext/config/stock.py +62,Items and Pricing,Položky a Ceny
+apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Položky a Ceny
 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: Appraisal,Select the Employee for whom you are creating the Appraisal.,"Vyberte zaměstnance, pro kterého vytváříte hodnocení."
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +93,Cost Center {0} does not belong to Company {1},Náklady Center {0} nepatří do společnosti {1}
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +97,Cost Center {0} does not belong to Company {1},Náklady Center {0} nepatří do společnosti {1}
 DocType: Customer,Individual,Individuální
-apps/erpnext/erpnext/config/support.py +27,Plan for maintenance visits.,Plán pro návštěvy údržby.
+apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plán pro návštěvy údržby.
 DocType: SMS Settings,Enter url parameter for message,Zadejte url parametr zprávy
-apps/erpnext/erpnext/config/stock.py +102,Rules for applying pricing and discount.,Pravidla pro používání cen a slevy.
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +81,This Time Log conflicts with {0} for {1} {2},Tentoraz sa Prihlásiť konflikty s {0} na {1} {2}
+apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Pravidla pro používání cen a slevy.
 apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Ceník musí být použitelný pro nákup nebo prodej
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Datum Instalace nemůže být před datem dodání pro bod {0}
-DocType: Pricing Rule,Discount on Price List Rate (%),Zľava na Cenník Rate (%)
+DocType: Pricing Rule,Discount on Price List Rate (%),Zľava z cenníkovej ceny (%)
 DocType: Offer Letter,Select Terms and Conditions,Vyberte Podmienky
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +51,Out Value,limitu
 DocType: Production Planning Tool,Sales Orders,Prodejní objednávky
@@ -212,12 +194,12 @@
 DocType: Selling Settings,Default Territory,Výchozí Territory
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Televize
 DocType: Production Order Operation,Updated via 'Time Log',"Aktualizováno přes ""Time Log"""
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +79,Account {0} does not belong to Company {1},Účet {0} nepatří do společnosti {1}
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +83,Account {0} does not belong to Company {1},Účet {0} nepatří do společnosti {1}
 apps/erpnext/erpnext/controllers/taxes_and_totals.py +413,Advance amount cannot be greater than {0} {1},Množstvo vopred nemôže byť väčšia ako {0} {1}
 DocType: Naming Series,Series List for this Transaction,Řada seznam pro tuto transakci
 DocType: Sales Invoice,Is Opening Entry,Je vstupní otvor
 DocType: Customer Group,Mention if non-standard receivable account applicable,Zmienka v prípade neštandardnej pohľadávky účet použiteľná
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +156,For Warehouse is required before Submit,Pro Sklad je povinné před Odesláním
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +170,For Warehouse is required before Submit,Pro Sklad je povinné před Odesláním
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Prijaté On
 DocType: Sales Partner,Reseller,Reseller
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +24,Please enter Company,"Prosím, zadejte společnost"
@@ -227,70 +209,64 @@
 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
 apps/erpnext/erpnext/controllers/recurring_document.py +227,Next Recurring {0} will be created on {1},Další Opakující {0} bude vytvořen na {1}
-DocType: Newsletter List,Total Subscribers,Celkom Odberatelia
 ,Contact Name,Kontakt Meno
 DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Vytvoří výplatní pásku na výše uvedených kritérií.
-apps/erpnext/erpnext/templates/generators/item.html +30,No description given,Bez popisu
+apps/erpnext/erpnext/templates/generators/item.html +78,No description given,Bez popisu
 apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Žádost o koupi.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +196,Only the selected Leave Approver can submit this Leave Application,Pouze vybraný Leave schvalovač může podat této dovolené aplikaci
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Relieving Date must be greater than Date of Joining,Uvolnění Datum musí být větší než Datum spojování
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +172,Leaves per Year,Listy za rok
-DocType: Time Log,Will be updated when batched.,Bude aktualizována při dávkově.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +114,Relieving Date must be greater than Date of Joining,Uvolnění Datum musí být větší než Datum spojování
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +181,Leaves per Year,Listy za rok
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,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 +178,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
+apps/erpnext/erpnext/stock/utils.py +188,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
 DocType: Item Website Specification,Item Website Specification,Položka webových stránek Specifikace
-DocType: Payment Tool,Reference No,Referenční číslo
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +425,Leave Blocked,Nechte Blokováno
-apps/erpnext/erpnext/stock/doctype/item/item.py +581,Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti na {1}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,Bank Entries,bankový Príspevky
-apps/erpnext/erpnext/accounts/utils.py +341,Annual,Roční
+apps/erpnext/erpnext/stock/doctype/item/item.py +666,Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti na {1}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +95,Bank Entries,bankový Príspevky
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +82,Annual,Roční
 DocType: Stock Reconciliation Item,Stock Reconciliation Item,Reklamní Odsouhlasení Item
 DocType: Stock Entry,Sales Invoice No,Prodejní faktuře č
 DocType: Material Request Item,Min Order Qty,Min Objednané množství
 DocType: Lead,Do Not Contact,Nekontaktujte
+DocType: Purchase Invoice,The unique id for tracking all recurring invoices. It is generated on submit.,Unikátní ID pro sledování všech opakující faktury. To je generován na odeslat.
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +93,Software Developer,Software Developer
 DocType: Item,Minimum Order Qty,Minimální objednávka Množství
 DocType: Pricing Rule,Supplier Type,Dodavatel Type
 DocType: Item,Publish in Hub,Publikovat v Hub
 ,Terretory,Terretory
-apps/erpnext/erpnext/stock/doctype/item/item.py +601,Item {0} is cancelled,Položka {0} je zrušená
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +709,Material Request,Požadavek na materiál
+apps/erpnext/erpnext/stock/doctype/item/item.py +686,Item {0} is cancelled,Položka {0} je zrušená
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +791,Material Request,Požadavek na materiál
 DocType: Bank Reconciliation,Update Clearance Date,Aktualizace Výprodej Datum
 DocType: Item,Purchase Details,Nákup Podrobnosti
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +323,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebol nájdený v &quot;suroviny dodanej&quot; tabuľky v objednávke {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +328,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebol nájdený v &quot;suroviny dodanej&quot; tabuľky v objednávke {1}
 DocType: Employee,Relation,Vztah
 DocType: Shipping Rule,Worldwide Shipping,Celosvetovo doprava
 apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
 DocType: Purchase Receipt Item,Rejected Quantity,Zamítnuto Množství
-DocType: Features Setup,"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Pole k dispozici v dodací list, cenovou nabídku, prodejní faktury odběratele"
 DocType: SMS Settings,SMS Sender Name,SMS Sender Name
 DocType: Contact,Is Primary Contact,Je primárně Kontakt
-apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +36,Time Log has been Batched for Billing,Time Log bol dávkované pre fakturáciu
 DocType: Notification Control,Notification Control,Oznámení Control
 DocType: Lead,Suggestions,Návrhy
 DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Položka Skupina-moudrý rozpočty na tomto území. Můžete také sezónnosti nastavením distribuce.
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +80,Please enter parent account group for warehouse {0},"Prosím, zadejte mateřskou skupinu účtu pro sklad {0}"
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +249,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Platba proti {0} {1} nemôže byť väčšia ako dlžnej čiastky {2}
 DocType: Supplier,Address HTML,Adresa HTML
 DocType: Lead,Mobile No.,Mobile No.
 DocType: Maintenance Schedule,Generate Schedule,Generování plán
 DocType: Purchase Invoice Item,Expense Head,Náklady Head
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +86,Please select Charge Type first,"Prosím, vyberte druh tarifu první"
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Nejnovější
-apps/erpnext/erpnext/public/js/setup_wizard.js +20,Max 5 characters,Max 5 znaků
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +102,Please select Charge Type first,"Prosím, vyberte druh tarifu první"
+apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Najnovšie
 DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,První Leave schvalovač v seznamu bude nastaven jako výchozí Leave schvalujícího
-apps/erpnext/erpnext/config/desktop.py +83,Learn,Učiť sa
+apps/erpnext/erpnext/config/desktop.py +158,Learn,Učiť sa
 DocType: Asset,Next Depreciation Date,Vedľa Odpisy Dátum
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Náklady na činnosť na jedného zamestnanca
 DocType: Accounts Settings,Settings for Accounts,Nastavenie Účtovníctva
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +483,Supplier Invoice No exists in Purchase Invoice {0},Dodávateľské faktúry No existuje vo faktúre {0}
-apps/erpnext/erpnext/config/crm.py +110,Manage Sales Person Tree.,Správa obchodník strom.
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +614,Supplier Invoice No exists in Purchase Invoice {0},Dodávateľské faktúry No existuje vo faktúre {0}
+apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Správa obchodník strom.
 DocType: Job Applicant,Cover Letter,Sprievodný list
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Outstanding Cheques and Deposits to clear,Vynikajúci Šeky a vklady s jasnými
+apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Vynikajúci Šeky a vklady s jasnými
 DocType: Item,Synced With Hub,Synchronizovány Hub
 apps/erpnext/erpnext/setup/doctype/company/company.js +63,Wrong Password,Zlé Heslo
 DocType: Item,Variant Of,Varianta
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +315,Completed Qty can not be greater than 'Qty to Manufacture',"Dokončené množství nemůže být větší než ""Množství do výroby"""
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +344,Completed Qty can not be greater than 'Qty to Manufacture',"Dokončené množství nemůže být větší než ""Množství do výroby"""
 DocType: Period Closing Voucher,Closing Account Head,Závěrečný účet hlava
 DocType: Employee,External Work History,Vnější práce History
 apps/erpnext/erpnext/projects/doctype/task/task.py +86,Circular Reference Error,Kruhové Referenčné Chyba
@@ -298,43 +274,40 @@
 apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednotiek [{1}] (# Form / bodu / {1}) bola nájdená v [{2}] (# Form / sklad / {2})
 DocType: Lead,Industry,Průmysl
 DocType: Employee,Job Profile,Job Profile
-DocType: Newsletter,Newsletter,Newsletter
 DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Upozornit e-mailem na tvorbu automatických Materiál Poptávka
 DocType: Journal Entry,Multi Currency,Viac mien
 DocType: Payment Reconciliation Invoice,Invoice Type,Typ faktúry
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +751,Delivery Note,Dodací list
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +763,Delivery Note,Dodací list
 apps/erpnext/erpnext/config/learn.py +87,Setting up Taxes,Nastavenie Dane
-apps/erpnext/erpnext/accounts/utils.py +191,Payment Entry has been modified after you pulled it. Please pull it again.,"Vstup Platba byla změněna poté, co ji vytáhl. Prosím, vytáhněte ji znovu."
-apps/erpnext/erpnext/stock/doctype/item/item.py +386,{0} entered twice in Item Tax,{0} vložené dvakrát v Daňovej Položke
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +105,Summary for this week and pending activities,Zhrnutie pre tento týždeň a prebiehajúcim činnostiam
+apps/erpnext/erpnext/accounts/utils.py +233,Payment Entry has been modified after you pulled it. Please pull it again.,"Vstup Platba byla změněna poté, co ji vytáhl. Prosím, vytáhněte ji znovu."
+apps/erpnext/erpnext/stock/doctype/item/item.py +442,{0} entered twice in Item Tax,{0} vložené dvakrát v Daňovej Položke
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +104,Summary for this week and pending activities,Zhrnutie pre tento týždeň a prebiehajúcim činnostiam
 DocType: Workstation,Rent Cost,Rent Cost
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +73,Please select month and year,Vyberte měsíc a rok
+DocType: Purchase Invoice,"Enter email id separated by commas, invoice will be mailed automatically on particular date","Zadejte e-mail id odděleny čárkami, bude faktura bude zaslán automaticky na určité datum"
 DocType: Employee,Company Email,E-mail spoločnosti
 DocType: GL Entry,Debit Amount in Account Currency,Debetné Čiastka v mene účtu
 DocType: Shipping Rule,Valid for Countries,"Platí pre krajiny,"
-DocType: Features Setup,"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Všech souvisejících oblastech, jako je dovozní měně, přepočítací koeficient, dovoz celkem, dovoz celkovém součtu etc jsou k dispozici v dokladu o koupi, dodavatelů nabídky, faktury, objednávky apod"
-apps/erpnext/erpnext/stock/doctype/item/item.js +48,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Tento bod je šablona a nemůže být použit v transakcích. Atributy položky budou zkopírovány do variant, pokud je nastaveno ""No Copy"""
+apps/erpnext/erpnext/stock/doctype/item/item.js +51,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Tento bod je šablona a nemůže být použit v transakcích. Atributy položky budou zkopírovány do variant, pokud je nastaveno ""No Copy"""
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Celková objednávka Zvážil
-apps/erpnext/erpnext/config/hr.py +190,"Employee designation (e.g. CEO, Director etc.).","Označení zaměstnanců (např CEO, ředitel atd.)."
+apps/erpnext/erpnext/config/hr.py +186,"Employee designation (e.g. CEO, Director etc.).","Označení zaměstnanců (např CEO, ředitel atd.)."
 apps/erpnext/erpnext/controllers/recurring_document.py +220,Please enter 'Repeat on Day of Month' field value,"Prosím, zadejte ""Opakujte dne měsíce"" hodnoty pole"
 DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je zákazník měny převeden na zákazníka základní měny"
-DocType: Features Setup,"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","K dispozici v BOM, dodací list, fakturu, výrobní zakázky, objednávky, doklad o koupi, prodejní faktury odběratele, Stock vstupu, časový rozvrh"
 DocType: Item Tax,Tax Rate,Sadzba dane
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +54,{0} already allocated for Employee {1} for period {2} to {3},{0} už pridelené pre zamestnancov {1} na dobu {2} až {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +677,Select Item,Select Položka
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +759,Select Item,Select Položka
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Item: {0} managed batch-wise, can not be reconciled using \
 					Stock Reconciliation, instead use Stock Entry","Item: {0} podařilo dávkové, nemůže být v souladu s použitím \
  Stock usmíření, použijte Reklamní Entry"
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +254,Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +90,Row # {0}: Batch No must be same as {1} {2},"Row # {0}: Batch No musí byť rovnaké, ako {1} {2}"
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +65,Convert to non-Group,Previesť na non-Group
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Purchase Receipt must be submitted,Příjmka musí být odeslána
-apps/erpnext/erpnext/config/stock.py +118,Batch (lot) of an Item.,Batch (lot) položky.
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +142,Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},"Row # {0}: Batch No musí byť rovnaké, ako {1} {2}"
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +47,Convert to non-Group,Previesť na non-Group
+apps/erpnext/erpnext/config/stock.py +117,Batch (lot) of an Item.,Batch (lot) položky.
 DocType: C-Form Invoice Detail,Invoice Date,Dátum fakturácie
 DocType: GL Entry,Debit Amount,Debetné Suma
-apps/erpnext/erpnext/accounts/party.py +223,There can only be 1 Account per Company in {0} {1},Tam môže byť len 1 účet na spoločnosti v {0} {1}
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Your email address,Vaša e-mailová adresa
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +213,Please see attachment,"Prosím, viz příloha"
+apps/erpnext/erpnext/accounts/party.py +242,There can only be 1 Account per Company in {0} {1},Tam môže byť len 1 účet na spoločnosti v {0} {1}
+apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +4,Your email address,Vaša e-mailová adresa
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +272,Please see attachment,"Prosím, viz příloha"
 DocType: Purchase Order,% Received,% Prijaté
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +19,Setup Already Complete!!,Setup již dokončen !!
 ,Finished Goods,Hotové zboží
@@ -348,37 +321,35 @@
 DocType: Packed Item,Packed Item,Zabalená položka
 apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Výchozí nastavení pro nákup transakcí.
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Existuje Náklady aktivity pre zamestnancov {0} proti Typ aktivity - {1}
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +29,Please do NOT create Accounts for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,"Prosím, nie vytvárať účty pre zákazníkov a dodávateľmi. Sú vytvorené priamo od zákazníka / dodávateľa majstrov."
 DocType: Currency Exchange,Currency Exchange,Směnárna
 DocType: Purchase Invoice Item,Item Name,Název položky
 DocType: Authorization Rule,Approving User  (above authorized value),Schválenie užívateľa (nad oprávnenej hodnoty)
 apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Credit Balance,Credit Balance
 DocType: Employee,Widowed,Ovdovělý
-DocType: Production Planning Tool,"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Položky, které je třeba požádat, které jsou ""Není skladem"" s ohledem na veškeré sklady na základě předpokládaného Množství a minimální Objednané množství"
 DocType: Request for Quotation,Request for Quotation,Žiadosť o cenovú ponuku
-DocType: Workstation,Working Hours,Pracovní doba
+DocType: Salary Slip Timesheet,Working Hours,Pracovní doba
 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.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +57,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","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/accounts/doctype/purchase_invoice/purchase_invoice.js +683,Purchase Return,Nákup Return
 ,Purchase Register,Nákup Register
 DocType: Landed Cost Item,Applicable Charges,Použitelné Poplatky
-DocType: Workstation,Consumable Cost,Spotřební Cost
+DocType: Workstation,Consumable Cost,Spotrebné náklady
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +192,{0} ({1}) must have role 'Leave Approver',"{0} ({1}), musí mať úlohu ""Schvalovateľ voľna"""
 DocType: Purchase Receipt,Vehicle Date,Dátum Vehicle
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +39,Medical,Lékařský
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +141,Reason for losing,Důvod ztráty
+apps/erpnext/erpnext/demo/setup_data.py +346,Medical,Lékařský
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +142,Reason for losing,Důvod ztráty
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +79,Workstation is closed on the following dates as per Holiday List: {0},Workstation je uzavřena v následujících dnech podle Prázdninový Seznam: {0}
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Príležitosti
 DocType: Employee,Single,Jednolůžkový
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +29,Budget cannot be set for Group Cost Center,Rozpočet nie je možné nastaviť pre skupinu nákladového strediska
 DocType: Account,Cost of Goods Sold,Náklady na prodej zboží
 DocType: Purchase Invoice,Yearly,Ročne
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +229,Please enter Cost Center,"Prosím, zadejte nákladové středisko"
 DocType: Journal Entry Account,Sales Order,Predajné objednávky
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +67,Avg. Selling Rate,Avg. Prodej Rate
-apps/erpnext/erpnext/utilities/transaction_base.py +131,Quantity cannot be a fraction in row {0},Množství nemůže být zlomek na řádku {0}
+apps/erpnext/erpnext/utilities/transaction_base.py +149,Quantity cannot be a fraction in row {0},Množství nemůže být zlomek na řádku {0}
 DocType: Purchase Invoice Item,Quantity and Rate,Množstvo a sadzba
 DocType: Delivery Note,% Installed,% Inštalovaných
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +59,Please enter company name first,"Prosím, zadajte najprv názov spoločnosti"
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +41,Please enter company name first,"Prosím, zadajte najprv názov spoločnosti"
 DocType: BOM,Item Desription,Položka Desription
 DocType: Purchase Invoice,Supplier Name,Dodavatel Name
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Prečítajte si ERPNext Manuál
@@ -387,7 +358,7 @@
 DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,"Skontrolujte, či dodávateľské faktúry Počet Jedinečnosť"
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',"""Do Prípadu č ' nesmie byť menší ako ""Od Prípadu č '"
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +104,Non Profit,Non Profit
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_list.js +7,Not Started,Nezahájené
+DocType: Production Order,Not Started,Nezahájené
 DocType: Lead,Channel Partner,Channel Partner
 DocType: Account,Old Parent,Staré nadřazené
 DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Přizpůsobte si úvodní text, který jede jako součást tohoto e-mailu. Každá transakce je samostatný úvodní text."
@@ -396,13 +367,13 @@
 apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.
 DocType: Accounts Settings,Accounts Frozen Upto,Účty Frozen aľ
 DocType: SMS Log,Sent On,Poslán na
-apps/erpnext/erpnext/stock/doctype/item/item.py +555,Attribute {0} selected multiple times in Attributes Table,Atribút {0} vybraný niekoľkokrát v atribútoch tabuľke
+apps/erpnext/erpnext/stock/doctype/item/item.py +635,Attribute {0} selected multiple times in Attributes Table,Atribút {0} vybraný niekoľkokrát v atribútoch tabuľke
 DocType: HR Settings,Employee record is created using selected field. ,Záznam Zaměstnanec je vytvořena pomocí vybrané pole.
 DocType: Sales Order,Not Applicable,Nehodí se
 apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Holiday master.
 DocType: Request for Quotation Item,Required Date,Požadovaná data
 DocType: Delivery Note,Billing Address,Fakturační adresa
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +773,Please enter Item Code.,"Prosím, zadejte kód položky."
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +809,Please enter Item Code.,"Prosím, zadejte kód položky."
 DocType: BOM,Costing,Rozpočet
 DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Je-li zaškrtnuto, bude částka daně považovat za již zahrnuty v tisku Rate / Tisk Částka"
 DocType: Request for Quotation,Message for Supplier,Správa pre dodávateľov
@@ -412,32 +383,27 @@
 DocType: Packing Slip,From Package No.,Od č balíčku
 DocType: Item Attribute,To Range,K Rozsah
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Cenné papíry a vklady
-DocType: Features Setup,Imports,Importy
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +77,Total leaves allocated is mandatory,Celkom listy pridelené je povinné
 DocType: Job Opening,Description of a Job Opening,Popis jednoho volných pozic
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +102,Pending activities for today,Nevybavené aktivity pre dnešok
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +101,Pending activities for today,Nevybavené aktivity pre dnešok
 apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Účast rekord.
-DocType: Bank Reconciliation,Journal Entries,Zápisy do Deníku
 DocType: Sales Order Item,Used for Production Plan,Používá se pro výrobní plán
 DocType: Manufacturing Settings,Time Between Operations (in mins),Doba medzi operáciou (v min)
 DocType: Customer,Buyer of Goods and Services.,Kupující zboží a služeb.
 DocType: Journal Entry,Accounts Payable,Účty za úplatu
 apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +29,The selected BOMs are not for the same item,Vybrané kusovníky nie sú rovnaké položky
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +24,Add Subscribers,Pridať predplatitelia
-apps/erpnext/erpnext/public/js/feature_setup.js +220,""" does not exists",""" Neexistuje"
 DocType: Pricing Rule,Valid Upto,Valid aľ
-apps/erpnext/erpnext/public/js/setup_wizard.js +212,List a few of your customers. They could be organizations or individuals.,"Vypíšte zopár svojich zákazníkov. Môžu to byť organizácie, ale aj jednotlivci."
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +146,Direct Income,Přímý příjmů
+apps/erpnext/erpnext/public/js/setup_wizard.js +238,List a few of your customers. They could be organizations or individuals.,"Vypíšte zopár svojich zákazníkov. Môžu to byť organizácie, ale aj jednotlivci."
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Direct Income,Přímý příjmů
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +33,"Can not filter based on Account, if grouped by Account","Nelze filtrovat na základě účtu, pokud seskupeny podle účtu"
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Administrative Officer,Správní ředitel
-DocType: Payment Tool,Received Or Paid,Přijaté nebo placené
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +308,Please select Company,"Prosím, vyberte Company"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +319,Please select Company,"Prosím, vyberte Company"
 DocType: Stock Entry,Difference Account,Rozdíl účtu
 apps/erpnext/erpnext/projects/doctype/task/task.py +44,Cannot close task as its dependant task {0} is not closed.,"Nedá zatvoriť úloha, ako jeho závislý úloha {0} nie je uzavretý."
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +381,Please enter Warehouse for which Material Request will be raised,"Prosím, zadejte sklad, který bude materiál žádosti předložené"
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +380,Please enter Warehouse for which Material Request will be raised,"Prosím, zadejte sklad, který bude materiál žádosti předložené"
 DocType: Production Order,Additional Operating Cost,Další provozní náklady
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,Kosmetika
-apps/erpnext/erpnext/stock/doctype/item/item.py +459,"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky"
+apps/erpnext/erpnext/stock/doctype/item/item.py +527,"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky"
 DocType: Shipping Rule,Net Weight,Hmotnost
 DocType: Employee,Emergency Phone,Nouzový telefon
 ,Serial No Warranty Expiry,Pořadové č záruční lhůty
@@ -445,9 +411,8 @@
 DocType: Purchase Invoice Item,Item,Položka
 DocType: Journal Entry,Difference (Dr - Cr),Rozdíl (Dr - Cr)
 DocType: Account,Profit and Loss,Zisky a ztráty
-apps/erpnext/erpnext/config/stock.py +315,Managing Subcontracting,Správa Subdodávky
+apps/erpnext/erpnext/config/stock.py +314,Managing Subcontracting,Správa Subdodávky
 DocType: Project,Project will be accessible on the website to these users,Projekt bude k dispozícii na webových stránkach k týmto užívateľom
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +47,Furniture and Fixture,Nábytek
 DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou Ceník měna je převedena na společnosti základní měny"
 apps/erpnext/erpnext/setup/doctype/company/company.py +53,Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1}
 apps/erpnext/erpnext/setup/doctype/company/company.py +44,Abbreviation already used for another company,Skratka už použitý pre inú spoločnosť
@@ -455,96 +420,91 @@
 DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Je-li zakázat, ""zaokrouhlí celková"" pole nebude viditelný v jakékoli transakce"
 DocType: BOM,Operating Cost,Provozní náklady
 DocType: Sales Order Item,Gross Profit,Hrubý Zisk
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +27,Increment cannot be 0,Prírastok nemôže byť 0
+apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +42,Increment cannot be 0,Prírastok nemôže byť 0
 DocType: Production Planning Tool,Material Requirement,Materiál Požadavek
 DocType: Company,Delete Company Transactions,Zmazať transakcií Company
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Item {0} is not Purchase Item,Položka {0} není Nákup položky
 DocType: Purchase Receipt,Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatků
 DocType: Purchase Invoice,Supplier Invoice No,Dodávateľská faktúra č
 DocType: Territory,For reference,Pro srovnání
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +154,"Cannot delete Serial No {0}, as it is used in stock transactions","Nemožno odstrániť Poradové číslo {0}, ktorý sa používa na sklade transakciách"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +232,Closing (Cr),Uzavření (Cr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +240,Closing (Cr),Uzavření (Cr)
 DocType: Serial No,Warranty Period (Days),Záruční doba (dny)
 DocType: Installation Note Item,Installation Note Item,Poznámka k instalaci bod
 DocType: Production Plan Item,Pending Qty,Čakajúci Množstvo
-DocType: Company,Ignore,Ignorovat
+DocType: Budget,Ignore,Ignorovat
 apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +86,SMS sent to following numbers: {0},SMS poslal do nasledujúcich čísel: {0}
-apps/erpnext/erpnext/controllers/buying_controller.py +127,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení
+apps/erpnext/erpnext/controllers/buying_controller.py +152,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení
 DocType: Pricing Rule,Valid From,Platnost od
 DocType: Sales Invoice,Total Commission,Celkem Komise
 DocType: Pricing Rule,Sales Partner,Sales Partner
 DocType: Buying Settings,Purchase Receipt Required,Příjmka je vyžadována
-DocType: Monthly Distribution,"**Monthly Distribution** helps you distribute your budget across months if you have seasonality in your business.
-
-To distribute a budget using this distribution, set this **Monthly Distribution** in the **Cost Center**","** Mesačné rozloženie** vám pomôže rozložiť váš rozpočet do viac mesiacov, ak vaše podnikanie ovplyvňuje sezónnosť. Ak chcete rozložiť rozpočet pomocou tohto rozdelenia, nastavte toto ** mesačné rozloženie ** v ** nákladovom stredisku **"
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +126,No records found in the Invoice table,Nalezené v tabulce faktury Žádné záznamy
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +20,Please select Company and Party Type first,Vyberte první společnost a Party Typ
-apps/erpnext/erpnext/config/accounts.py +238,Financial / accounting year.,Finanční / Účetní rok.
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.js +10,Accumulated Values,neuhradená Hodnoty
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +142,No records found in the Invoice table,Nalezené v tabulce faktury Žádné záznamy
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +28,Please select Company and Party Type first,Vyberte první společnost a Party Typ
+apps/erpnext/erpnext/config/accounts.py +251,Financial / accounting year.,Finanční / Účetní rok.
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.js +9,Accumulated Values,neuhradená Hodnoty
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit"
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +664,Make Sales Order,Ujistěte se prodejní objednávky
 DocType: Project Task,Project Task,Úloha Project
 ,Lead Id,Id Obchodnej iniciatívy
 DocType: C-Form Invoice Detail,Grand Total,Celkem
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +36,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Datum zahájení Fiskálního roku by nemělo být větší než datum ukončení
-DocType: Warranty Claim,Resolution,Řešení
-apps/erpnext/erpnext/templates/pages/order.html +61,Delivered: {0},Dodáva: {0}
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +66,Payable Account,Splatnost účtu
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Datum zahájení Fiskálního roku by nemělo být větší než datum ukončení
+DocType: Issue,Resolution,Řešení
+apps/erpnext/erpnext/templates/pages/order.html +53,Delivered: {0},Dodáva: {0}
+apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +69,Payable Account,Splatnost účtu
 DocType: Sales Order,Billing and Delivery Status,Fakturácie a Delivery Status
 DocType: Job Applicant,Resume Attachment,Resume Attachment
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Opakujte zákazníci
+apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Verní zákazníci
 DocType: Leave Control Panel,Allocate,Přidělit
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +683,Sales Return,Sales Return
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +691,Sales Return,Sales Return
 DocType: Item,Delivered by Supplier (Drop Ship),Dodáva Dodávateľom (Drop Ship)
-apps/erpnext/erpnext/config/hr.py +115,Salary components.,Mzdové složky.
 apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Databáze potenciálních zákazníků.
 DocType: Authorization Rule,Customer or Item,Zákazník alebo položka
-apps/erpnext/erpnext/config/crm.py +22,Customer database.,Databáze zákazníků.
+apps/erpnext/erpnext/config/selling.py +28,Customer database.,Databáze zákazníků.
 DocType: Quotation,Quotation To,Ponuka k
 DocType: Lead,Middle Income,Středními příjmy
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +58,Opening (Cr),Otvor (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +707,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Východzí merná jednotka bodu {0} nemôže byť zmenená priamo, pretože ste už nejaké transakcie (y) s iným nerozpustených. Budete musieť vytvoriť novú položku použiť iný predvolený UOM."
-apps/erpnext/erpnext/accounts/utils.py +195,Allocated amount can not be negative,Přidělená částka nemůže být záporná
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +212,Opening (Cr),Otvor (Cr)
+apps/erpnext/erpnext/stock/doctype/item/item.py +792,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Východzí merná jednotka bodu {0} nemôže byť zmenená priamo, pretože ste už nejaké transakcie (y) s iným nerozpustených. Budete musieť vytvoriť novú položku použiť iný predvolený UOM."
+apps/erpnext/erpnext/accounts/utils.py +237,Allocated amount can not be negative,Přidělená částka nemůže být záporná
 DocType: Purchase Order Item,Billed Amt,Účtovaného Amt
 DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny."
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +91,Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0}
 DocType: Sales Invoice,Customer's Vendor,Prodejce zákazníka
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +211,Production Order is Mandatory,Výrobní zakázka je povinné
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +139,Proposal Writing,Návrh Psaní
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +148,Proposal Writing,Návrh Psaní
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Ďalšia predaja osoba {0} existuje s rovnakým id zamestnanca
-apps/erpnext/erpnext/config/accounts.py +70,Masters,Masters
-apps/erpnext/erpnext/config/accounts.py +135,Update Bank Transaction Dates,Transakčné Data aktualizácie Bank
-apps/erpnext/erpnext/stock/stock_ledger.py +337,Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negativní Sklad Error ({6}) k bodu {0} ve skladu {1} na {2} {3} v {4} {5}
+apps/erpnext/erpnext/config/accounts.py +74,Masters,Masters
+apps/erpnext/erpnext/config/accounts.py +134,Update Bank Transaction Dates,Transakčné Data aktualizácie Bank
 apps/erpnext/erpnext/config/projects.py +30,Time Tracking,Time Tracking
 DocType: Fiscal Year Company,Fiscal Year Company,Fiskální rok Společnosti
 DocType: Packing Slip Item,DN Detail,DN Detail
-DocType: Time Log,Billed,Fakturováno
+DocType: Timesheet,Billed,Fakturováno
 DocType: Batch,Batch Description,Popis Šarže
 DocType: Delivery Note,Time at which items were delivered from warehouse,"Čas, kdy byly předměty dodány od skladu"
 DocType: Sales Invoice,Sales Taxes and Charges,Prodej Daně a poplatky
 DocType: Employee,Organization Profile,Profil organizace
 DocType: Employee,Reason for Resignation,Důvod rezignace
-apps/erpnext/erpnext/config/hr.py +151,Template for performance appraisals.,Šablona pro hodnocení výkonu.
+apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Šablona pro hodnocení výkonu.
 DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti
 apps/erpnext/erpnext/accounts/utils.py +53,{0} '{1}' not in Fiscal Year {2},{0} '{1}' nie je vo fiškálnom roku {2}
 DocType: Buying Settings,Settings for Buying Module,Nastavenie pre modul Nákupy
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +62,Please enter Purchase Receipt first,"Prosím, zadejte první doklad o zakoupení"
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +69,Please enter Purchase Receipt first,"Prosím, zadejte první doklad o zakoupení"
 DocType: Buying Settings,Supplier Naming By,Pomenovanie dodávateľa podľa
 DocType: Activity Type,Default Costing Rate,Predvolené kalkulácie Rate
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +703,Maintenance Schedule,Plán údržby
+DocType: Maintenance Schedule,Maintenance Schedule,Plán údržby
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +34,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Pak se pravidla pro tvorbu cen jsou odfiltrovány založeny na zákazníka, skupiny zákazníků, území, dodavatel, dodavatel typ, kampaň, obchodní partner atd"
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Inventory,Čistá Zmena stavu zásob
 DocType: Employee,Passport Number,Číslo pasu
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +82,Manager,Manažer
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +229,Same item has been entered multiple times.,Stejný bod byl zadán vícekrát.
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +82,Manager,Manažér
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +227,Same item has been entered multiple times.,Stejný bod byl zadán vícekrát.
 DocType: SMS Settings,Receiver Parameter,Přijímač parametrů
 apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""Založené na"" a ""Zoskupené podľa"", nemôžu byť rovnaké"
 DocType: Sales Person,Sales Person Targets,Obchodník cíle
+apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter email address,Zadejte e-mailovou adresu
 DocType: Production Order Operation,In minutes,V minútach
 DocType: Issue,Resolution Date,Rozlišení Datum
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +699,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 +693,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}
 DocType: Selling Settings,Customer Naming By,Zákazník Pojmenování By
 DocType: Depreciation Schedule,Depreciation Amount,odpisy Suma
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +69,Convert to Group,Převést do skupiny
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +51,Convert to Group,Převést do skupiny
 DocType: Activity Cost,Activity Type,Druh činnosti
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Dodává Částka
 DocType: Supplier,Fixed Days,Pevné Dni
@@ -554,87 +514,79 @@
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,Publikování
 DocType: Activity Cost,Projects User,Projekty uživatele
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Spotřeba
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +141,{0}: {1} not found in Invoice Details table,{0}: {1} nenájdené v tabuľke Podrobnosti Faktúry
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} nenájdené v tabuľke Podrobnosti Faktúry
 DocType: Company,Round Off Cost Center,Zaokrúhliť nákladové stredisko
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +202,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Navštivte {0} musí být zrušena před zrušením této prodejní objednávky
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +205,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Navštivte {0} musí být zrušena před zrušením této prodejní objednávky
 DocType: Material Request,Material Transfer,Přesun materiálu
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +56,Opening (Dr),Opening (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +205,Opening (Dr),Opening (Dr)
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Časová značka zadání musí být po {0}
 DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Přistál nákladů daně a poplatky
 DocType: Production Order Operation,Actual Start Time,Skutečný čas začátku
 DocType: BOM Operation,Operation Time,Provozní doba
 DocType: Pricing Rule,Sales Manager,Manažer prodeje
-apps/erpnext/erpnext/accounts/doctype/account/account.js +67,Group to Group,Skupiny k skupine
-apps/erpnext/erpnext/projects/doctype/project/project.py +164,My Projects,moje projekty
 DocType: Journal Entry,Write Off Amount,Odepsat Částka
 DocType: Journal Entry,Bill No,Bill No
 DocType: Company,Gain/Loss Account on Asset Disposal,Zisk / straty na majetku likvidáciu
 DocType: Purchase Invoice,Quarterly,Čtvrtletně
-DocType: Selling Settings,Delivery Note Required,Delivery Note Povinné
+DocType: Selling Settings,Delivery Note Required,Dodací list povinný
 DocType: Sales Order Item,Basic Rate (Company Currency),Basic Rate (Company měny)
 DocType: Manufacturing Settings,Backflush Raw Materials Based On,So spätným suroviny na základe
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +57,Please enter item details,"Prosím, zadejte podrobnosti položky"
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +53,Please enter item details,"Prosím, zadejte podrobnosti položky"
 DocType: Purchase Receipt,Other Details,Ďalšie podrobnosti
 DocType: Account,Accounts,Účty
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +67,Marketing,Marketing
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +223,Payment Entry is already created,Vstup Platba je už vytvorili
-DocType: Features Setup,To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Chcete-li sledovat položky v oblasti prodeje a nákupu dokumentů na základě jejich sériových čísel. To je možné také použít ke sledování detailů produktu záruční.
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +227,Payment Entry is already created,Vstup Platba je už vytvorili
 DocType: Purchase Receipt Item Supplied,Current Stock,Current skladem
-apps/erpnext/erpnext/controllers/accounts_controller.py +473,Row #{0}: Asset {1} does not linked to Item {2},Riadok # {0}: Asset {1} nie je spojená s item {2}
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +67,Total billing this year,Celkom fakturácia tento rok
+apps/erpnext/erpnext/controllers/accounts_controller.py +538,Row #{0}: Asset {1} does not linked to Item {2},Riadok # {0}: Asset {1} nie je spojená s item {2}
 DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
 DocType: Employee,Provide email id registered in company,Poskytnout e-mail id zapsané ve firmě
 DocType: Hub Settings,Seller City,Prodejce City
 DocType: Email Digest,Next email will be sent on:,Další e-mail bude odeslán dne:
 DocType: Offer Letter Term,Offer Letter Term,Ponuka Letter Term
-apps/erpnext/erpnext/stock/doctype/item/item.py +534,Item has variants.,Položka má varianty.
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +67,Item {0} not found,Položka {0} nebyl nalezen
+apps/erpnext/erpnext/stock/doctype/item/item.py +614,Item has variants.,Položka má varianty.
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +68,Item {0} not found,Položka {0} nebyl nalezen
 DocType: Bin,Stock Value,Reklamní Value
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +88,Tree Type,Tree Type
 DocType: BOM Explosion Item,Qty Consumed Per Unit,Množství spotřebované na jednotku
 DocType: Serial No,Warranty Expiry Date,Záruka Datum vypršení platnosti
 DocType: Material Request Item,Quantity and Warehouse,Množství a sklad
-DocType: Sales Invoice,Commission Rate (%),Výše provize (%)
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +176,"Against Voucher Type must be one of Sales Order, Sales Invoice or Journal Entry","Proti poukazu Type musí být jedním z prodejní objednávky, prodejní faktury nebo Journal Entry"
+DocType: Sales Invoice,Commission Rate (%),Výška provízie (%)
 DocType: Project,Estimated Cost,odhadované náklady
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Aerospace
 DocType: Journal Entry,Credit Card Entry,Vstup Kreditní karta
-apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +18,Task Subject,Úkol Předmět
-apps/erpnext/erpnext/config/accounts.py +40,Company and Accounts,Spoločnosť a účty
+apps/erpnext/erpnext/config/accounts.py +45,Company and Accounts,Spoločnosť a účty
 apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Zboží od dodavatelů.
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +49,In Value,v Hodnota
 DocType: Lead,Campaign Name,Název kampaně
 ,Reserved,Rezervováno
 DocType: Purchase Order,Supply Raw Materials,Dodávok surovín
+DocType: Purchase Invoice,The date on which next invoice will be generated. It is generated on submit.,"Datum, kdy bude vygenerován příští faktury. To je generován na odeslat."
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Oběžná aktiva
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +91,{0} is not a stock Item,{0} nie je skladová položka
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +90,{0} is not a stock Item,{0} nie je skladová položka
 DocType: Mode of Payment Account,Default Account,Výchozí účet
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +155,Lead must be set if Opportunity is made from Lead,Vedoucí musí být nastavena pokud Opportunity je vyrobena z olova
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +49,Customer &gt; Customer Group &gt; Territory,Customer&gt; Customer Group&gt; Územie
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +167,Lead must be set if Opportunity is made from Lead,Vedoucí musí být nastavena pokud Opportunity je vyrobena z olova
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,"Prosím, vyberte týdenní off den"
 DocType: Production Order Operation,Planned End Time,Plánované End Time
 ,Sales Person Target Variance Item Group-Wise,Prodej Osoba Cílová Odchylka Item Group-Wise
-apps/erpnext/erpnext/accounts/doctype/account/account.py +92,Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu
+apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu
 DocType: Delivery Note,Customer's Purchase Order No,Zákazníka Objednávka No
 DocType: Employee,Cell Number,Číslo buňky
-apps/erpnext/erpnext/stock/reorder_item.py +166,Auto Material Requests Generated,Žiadosti Auto materiál vygenerovaný
+apps/erpnext/erpnext/stock/reorder_item.py +177,Auto Material Requests Generated,Žiadosti Auto materiál vygenerovaný
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Ztracený
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +125,You can not enter current voucher in 'Against Journal Entry' column,"Nelze zadat aktuální poukaz v ""Proti Zápis do deníku"" sloupci"
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,Energie
 DocType: Opportunity,Opportunity From,Příležitost Z
 apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Měsíční plat prohlášení.
 DocType: Item Group,Website Specifications,Webových stránek Specifikace
-apps/erpnext/erpnext/utilities/doctype/address/address.py +103,There is an error in your Address Template {0},Tam je chyba v adrese šablóne {0}
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +207,New Account,Nový účet
+apps/erpnext/erpnext/utilities/doctype/address/address.py +104,There is an error in your Address Template {0},Tam je chyba v adrese šablóne {0}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +23,{0}: From {0} of type {1},{0}: Od {0} typu {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +275,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
+apps/erpnext/erpnext/controllers/buying_controller.py +283,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +274,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Viac Cena pravidlá existuje u rovnakých kritérií, prosím vyriešiť konflikt tým, že priradí prioritu. Cena Pravidlá: {0}"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +27,Accounting Entries can be made against leaf nodes. Entries against Groups are not allowed.,Účtovné Prihlášky možno proti koncovej uzly. Záznamy proti skupinám nie sú povolené.
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +371,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nelze deaktivovat nebo zrušit BOM, jak to souvisí s ostatními kusovníky"
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +369,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nelze deaktivovat nebo zrušit BOM, jak to souvisí s ostatními kusovníky"
 DocType: Opportunity,Maintenance,Údržba
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +190,Purchase Receipt number required for Item {0},Číslo příjmky je potřeba pro položku {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +206,Purchase Receipt number required for Item {0},Číslo příjmky je potřeba pro položku {0}
 DocType: Item Attribute Value,Item Attribute Value,Položka Hodnota atributu
-apps/erpnext/erpnext/config/crm.py +84,Sales campaigns.,Prodej kampaně.
+apps/erpnext/erpnext/config/selling.py +148,Sales campaigns.,Prodej kampaně.
 DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
 
 #### Note
@@ -675,88 +627,81 @@
  8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).
  9. Je to poplatek v ceně do základní sazby ?: Pokud se to ověřit, znamená to, že tato daň nebude zobrazen pod tabulkou položky, ale budou zahrnuty do základní sazby v hlavním položce tabulky. To je užitečné, pokud chcete dát paušální cenu (včetně všech poplatků), ceny pro zákazníky."
 DocType: Employee,Bank A/C No.,"Č, bank. účtu"
-DocType: Purchase Invoice Item,Project,Projekt
+DocType: GL Entry,Project,Projekt
 DocType: Quality Inspection Reading,Reading 7,Čtení 7
 DocType: Address,Personal,Osobní
 DocType: Expense Claim Detail,Expense Claim Type,Náklady na pojistná Type
 DocType: Shopping Cart Settings,Default settings for Shopping Cart,Výchozí nastavení Košík
-apps/erpnext/erpnext/controllers/accounts_controller.py +333,"Journal Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Zápis do deníku {0} je spojen proti řádu {1}, zkontrolujte, zda by měl být tažen za pokrok v této faktuře."
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Biotechnologie
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Office Maintenance Expenses,Náklady Office údržby
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +111,Please enter Item first,"Prosím, nejdřív zadejte položku"
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +107,Office Maintenance Expenses,Náklady Office údržby
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +115,Please enter Item first,"Prosím, nejdřív zadejte položku"
 DocType: Account,Liability,Odpovědnost
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +60,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionovaná Čiastka nemôže byť väčšia ako reklamácia Suma v riadku {0}.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +61,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionovaná Čiastka nemôže byť väčšia ako reklamácia Suma v riadku {0}.
 DocType: Company,Default Cost of Goods Sold Account,Východiskové Náklady na predaný tovar účte
-apps/erpnext/erpnext/stock/get_item_details.py +274,Price List not selected,Ceník není zvolen
+apps/erpnext/erpnext/stock/get_item_details.py +275,Price List not selected,Ceník není zvolen
 DocType: Employee,Family Background,Rodinné poměry
-DocType: Process Payroll,Send Email,Odeslat email
-apps/erpnext/erpnext/stock/doctype/item/item.py +152,Warning: Invalid Attachment {0},Varovanie: Neplatná Príloha {0}
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +88,No Permission,Nemáte oprávnenie
+DocType: Request for Quotation Supplier,Send Email,Odeslat email
+apps/erpnext/erpnext/stock/doctype/item/item.py +201,Warning: Invalid Attachment {0},Varovanie: Neplatná Príloha {0}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +709,No Permission,Nemáte oprávnenie
 DocType: Company,Default Bank Account,Prednastavený Bankový účet
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +47,"To filter based on Party, select Party Type first","Ak chcete filtrovať na základe Party, vyberte typ Party prvý"
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"""Aktualizovať Sklad ' nie je možné skontrolovať, pretože položky nie sú dodané cez {0}"
-apps/erpnext/erpnext/public/js/setup_wizard.js +272,Nos,Balenie
+apps/erpnext/erpnext/public/js/setup_wizard.js +298,Nos,Balenie
 DocType: Item,Items with higher weightage will be shown higher,Položky s vyšším weightage budú zobrazené vyššie
 DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Odsouhlasení Detail
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +691,My Invoices,Moje Faktúry
-apps/erpnext/erpnext/controllers/accounts_controller.py +476,Row #{0}: Asset {1} must be submitted,Riadok # {0}: {1} Asset musia byť predložené
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +43,No employee found,Nenájdený žiadny zamestnanec
+apps/erpnext/erpnext/controllers/accounts_controller.py +542,Row #{0}: Asset {1} must be submitted,Riadok # {0}: {1} Asset musia byť predložené
+apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Nenájdený žiadny zamestnanec
 DocType: Supplier Quotation,Stopped,Zastaveno
 DocType: Item,If subcontracted to a vendor,Ak sa subdodávky na dodávateľa
-apps/erpnext/erpnext/manufacturing/page/bom_browser/bom_browser.js +17,Select BOM to start,Vyberte BOM na začiatok
 DocType: SMS Center,All Customer Contact,Všetky Kontakty Zákazníka
-apps/erpnext/erpnext/config/stock.py +149,Upload stock balance via csv.,Nahrát nutnosti rovnováhy prostřednictvím CSV.
+apps/erpnext/erpnext/config/stock.py +148,Upload stock balance via csv.,Nahrát nutnosti rovnováhy prostřednictvím CSV.
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +27,Send Now,Odeslat nyní
 ,Support Analytics,Podpora Analytics
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +196,Logical error: Must find overlapping,Logická chyba: musí nájsť prekrývania
 DocType: Item,Website Warehouse,Sklad pro web
 DocType: Payment Reconciliation,Minimum Invoice Amount,Minimálna suma faktúry
+DocType: Purchase Invoice,"The day of the month on which auto invoice will be generated e.g. 05, 28 etc","Den měsíce, ve kterém auto faktura bude generován například 05, 28 atd"
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Skóre musí být menší než nebo rovna 5
-apps/erpnext/erpnext/config/accounts.py +275,C-Form records,C-Form záznamy
-apps/erpnext/erpnext/config/selling.py +301,Customer and Supplier,Zákazník a Dodávateľ
+apps/erpnext/erpnext/config/accounts.py +288,C-Form records,C-Form záznamy
+apps/erpnext/erpnext/config/selling.py +297,Customer and Supplier,Zákazník a Dodávateľ
 DocType: Email Digest,Email Digest Settings,Nastavení e-mailu Digest
 apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Podpora dotazy ze strany zákazníků.
-DocType: Features Setup,"To enable ""Point of Sale"" features",Ak chcete povoliť &quot;Point of Sale&quot; predstavuje
 DocType: Bin,Moving Average Rate,Klouzavý průměr
 DocType: Production Planning Tool,Select Items,Vyberte položky
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +342,{0} against Bill {1} dated {2},{0} proti účtu {1} z dňa {2}
 DocType: Maintenance Visit,Completion Status,Dokončení Status
-DocType: Production Order,Target Warehouse,Target Warehouse
+apps/erpnext/erpnext/accounts/doctype/asset/asset.js +229,Target Warehouse,Target Warehouse
 DocType: Item,Allow over delivery or receipt upto this percent,Nechajte cez dodávku alebo príjem aľ tohto percenta
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +50,Expected Delivery Date cannot be before Sales Order Date,"Očekávané datum dodání, nemůže být před Sales pořadí Datum"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +53,Expected Delivery Date cannot be before Sales Order Date,"Očekávané datum dodání, nemůže být před Sales pořadí Datum"
 DocType: Upload Attendance,Import Attendance,Importovat Docházku
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +17,All Item Groups,Všechny skupiny položek
 DocType: Process Payroll,Activity Log,Aktivita Log
-apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +34,Net Profit / Loss,Čistý zisk / strata
-apps/erpnext/erpnext/config/setup.py +94,Automatically compose message on submission of transactions.,Automaticky napsat vzkaz na předkládání transakcí.
+apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +36,Net Profit / Loss,Čistý zisk / strata
+apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Automaticky napsat vzkaz na předkládání transakcí.
 DocType: Production Order,Item To Manufacture,Bod K výrobě
-apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +87,{0} {1} status is {2},{0} {1} stav je {2}
+apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +82,{0} {1} status is {2},{0} {1} stav je {2}
 DocType: Shopping Cart Settings,Enable Checkout,aktivovať Checkout
 apps/erpnext/erpnext/config/learn.py +207,Purchase Order to Payment,Objednávka na platobné
-DocType: Quotation Item,Projected Qty,Předpokládané množství
+apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +37,Projected Qty,Předpokládané množství
 DocType: Sales Invoice,Payment Due Date,Splatno dne
-DocType: Newsletter,Newsletter Manager,Newsletter Manažér
-apps/erpnext/erpnext/stock/doctype/item/item.js +227,Item Variant {0} already exists with same attributes,Variant Položky {0} už existuje s rovnakými vlastnosťami
+apps/erpnext/erpnext/stock/doctype/item/item.js +270,Item Variant {0} already exists with same attributes,Variant Položky {0} už existuje s rovnakými vlastnosťami
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +95,'Opening',"""Otváranie"""
 DocType: Notification Control,Delivery Note Message,Delivery Note Message
 DocType: Expense Claim,Expenses,Výdaje
 DocType: Item Variant Attribute,Item Variant Attribute,Vlastnosť Variantu Položky
 ,Purchase Receipt Trends,Doklad o koupi Trendy
-DocType: Appraisal,Select template from which you want to get the Goals,"Vyberte šablonu, ze kterého chcete získat cílů"
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +77,Research & Development,Výzkum a vývoj
 ,Amount to Bill,Částka k Fakturaci
 DocType: Company,Registration Details,Registrace Podrobnosti
 DocType: Item Reorder,Re-Order Qty,Re-Order Množství
 DocType: Leave Block List Date,Leave Block List Date,Nechte Block List Datum
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +25,Scheduled to send to {0},Plánované poslat na {0}
 DocType: Pricing Rule,Price or Discount,Cena nebo Sleva
 DocType: Sales Team,Incentives,Pobídky
 DocType: SMS Log,Requested Numbers,Požadované Čísla
-apps/erpnext/erpnext/config/hr.py +146,Performance appraisal.,Hodnocení výkonu.
+apps/erpnext/erpnext/config/hr.py +142,Performance appraisal.,Hodnocení výkonu.
 DocType: Sales Invoice Item,Stock Details,Sklad Podrobnosti
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Hodnota projektu
-apps/erpnext/erpnext/config/selling.py +311,Point-of-Sale,Mieste predaja
-apps/erpnext/erpnext/accounts/doctype/account/account.py +115,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zůstatek na účtu již v Credit, není dovoleno stanovit ""Balance musí být"" jako ""debet"""
+apps/erpnext/erpnext/config/selling.py +307,Point-of-Sale,Mieste predaja
+apps/erpnext/erpnext/accounts/doctype/account/account.py +119,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zůstatek na účtu již v Credit, není dovoleno stanovit ""Balance musí být"" jako ""debet"""
 DocType: Account,Balance must be,Zůstatek musí být
 DocType: Hub Settings,Publish Pricing,Publikovat Ceník
 DocType: Notification Control,Expense Claim Rejected Message,Zpráva o zamítnutí úhrady výdajů
@@ -765,26 +710,25 @@
 DocType: Salary Slip,Working Days,Pracovní dny
 DocType: Serial No,Incoming Rate,Příchozí Rate
 DocType: Packing Slip,Gross Weight,Hrubá hmotnost
-apps/erpnext/erpnext/public/js/setup_wizard.js +44,The name of your company for which you are setting up this system.,"Názov spoločnosti, pre ktorú nastavujete tento systém"
+apps/erpnext/erpnext/public/js/setup_wizard.js +67,The name of your company for which you are setting up this system.,"Názov spoločnosti, pre ktorú nastavujete tento systém"
 DocType: HR Settings,Include holidays in Total no. of Working Days,Zahrnout dovolenou v celkovém. pracovních dní
 DocType: Job Applicant,Hold,Držet
 DocType: Employee,Date of Joining,Datum přistoupení
 DocType: Naming Series,Update Series,Řada Aktualizace
 DocType: Supplier Quotation,Is Subcontracted,Subdodavatelům
 DocType: Item Attribute,Item Attribute Values,Položka Hodnoty atributů
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +3,View Subscribers,Zobraziť Odberatelia
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +621,Purchase Receipt,Příjemka
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +703,Purchase Receipt,Příjemka
 ,Received Items To Be Billed,"Přijaté položek, které mají být účtovány"
 DocType: Employee,Ms,Paní
-apps/erpnext/erpnext/config/accounts.py +248,Currency exchange rate master.,Devizový kurz master.
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +265,Unable to find Time Slot in the next {0} days for Operation {1},Nemožno nájsť časový úsek v najbližších {0} dní na prevádzku {1}
+apps/erpnext/erpnext/config/accounts.py +261,Currency exchange rate master.,Devizový kurz master.
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +278,Unable to find Time Slot in the next {0} days for Operation {1},Nemožno nájsť časový úsek v najbližších {0} dní na prevádzku {1}
 DocType: Production Order,Plan material for sub-assemblies,Plán materiál pro podsestavy
-apps/erpnext/erpnext/config/selling.py +99,Sales Partners and Territory,Obchodní partneri a teritóriá
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +436,BOM {0} must be active,BOM {0} musí být aktivní
+apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Obchodní partneri a teritória
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +439,BOM {0} must be active,BOM {0} musí být aktivní
 DocType: Journal Entry,Depreciation Entry,odpisy Entry
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Vyberte první typ dokumentu
-apps/erpnext/erpnext/templates/generators/item.html +74,Goto Cart,Goto košík
-apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušit Materiál Návštěvy {0} před zrušením tohoto návštěv údržby
+apps/erpnext/erpnext/templates/generators/item.html +68,Goto Cart,Goto košík
+apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušit Materiál Návštěvy {0} před zrušením tohoto návštěv údržby
 DocType: Salary Slip,Leave Encashment Amount,Nechte inkasa Částka
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +209,Serial No {0} does not belong to Item {1},Pořadové číslo {0} nepatří k bodu {1}
 DocType: Purchase Receipt Item Supplied,Required Qty,Požadované množství
@@ -799,8 +743,7 @@
 DocType: Purchase Receipt,Range,Rozsah
 DocType: Supplier,Default Payable Accounts,Výchozí úplatu účty
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +40,Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje
-DocType: Features Setup,Item Barcode,Položka Barcode
-apps/erpnext/erpnext/stock/doctype/item/item.py +529,Item Variants {0} updated,Varianty Položky {0} aktualizované
+apps/erpnext/erpnext/stock/doctype/item/item.py +609,Item Variants {0} updated,Varianty Položky {0} aktualizované
 DocType: Quality Inspection Reading,Reading 6,Čtení 6
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Záloha přijaté faktury
 DocType: Address,Shop,Obchod
@@ -809,10 +752,8 @@
 DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Výchozí účet Bank / Cash budou automaticky aktualizovány v POS faktury, pokud je zvolen tento režim."
 DocType: Employee,Permanent Address Is,Trvalé bydliště je
 DocType: Production Order Operation,Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?
-apps/erpnext/erpnext/public/js/setup_wizard.js +139,The Brand,Značka
-apps/erpnext/erpnext/controllers/status_updater.py +165,Allowance for over-{0} crossed for Item {1}.,Příspěvek na nadměrné {0} přešel k bodu {1}.
+apps/erpnext/erpnext/public/js/setup_wizard.js +162,The Brand,Značka
 DocType: Employee,Exit Interview Details,Exit Rozhovor Podrobnosti
-DocType: Item,Is Purchase Item,je Nákupní Položka
 DocType: Asset,Purchase Invoice,Přijatá faktura
 DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail No
 DocType: Stock Entry,Total Outgoing Value,Celková hodnota Odchozí
@@ -821,19 +762,18 @@
 DocType: Payment Request,Paid,Placený
 DocType: Salary Slip,Total in words,Celkem slovy
 DocType: Material Request Item,Lead Time Date,Čas a Dátum Obchodnej iniciatívy
-apps/erpnext/erpnext/public/js/controllers/taxes_and_totals.js +54, is mandatory. Maybe Currency Exchange record is not created for ,"je povinné. Možno, Zmenáreň záznam nie je vytvorená pre"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +110,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +542,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pre &quot;produktom Bundle predmety, sklad, sériové číslo a dávkové No bude považovaná zo&quot; Balenie zoznam &#39;tabuľky. Ak Warehouse a Batch No sú rovnaké pre všetky balenia položky pre akúkoľvek &quot;Výrobok balík&quot; položky, tieto hodnoty môžu byť zapísané do hlavnej tabuľky položky, budú hodnoty skopírované do &quot;Balenie zoznam&quot; tabuľku."
+apps/erpnext/erpnext/accounts/page/pos/pos.js +86, is mandatory. Maybe Currency Exchange record is not created for ,"je povinné. Možno, Zmenáreň záznam nie je vytvorená pre"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +109,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +576,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pre &quot;produktom Bundle predmety, sklad, sériové číslo a dávkové No bude považovaná zo&quot; Balenie zoznam &#39;tabuľky. Ak Warehouse a Batch No sú rovnaké pre všetky balenia položky pre akúkoľvek &quot;Výrobok balík&quot; položky, tieto hodnoty môžu byť zapísané do hlavnej tabuľky položky, budú hodnoty skopírované do &quot;Balenie zoznam&quot; tabuľku."
 DocType: Job Opening,Publish on website,Publikovať na webových stránkach
 apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Zásilky zákazníkům.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +463,Supplier Invoice Date cannot be greater than Posting Date,Dodávateľ Dátum faktúry nemôže byť väčšia ako Dátum zverejnenia
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +594,Supplier Invoice Date cannot be greater than Posting Date,Dodávateľ Dátum faktúry nemôže byť väčšia ako Dátum zverejnenia
 DocType: Purchase Invoice Item,Purchase Order Item,Položka vydané objednávky
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Indirect Income,Nepřímé příjmy
-DocType: Payment Tool,Set Payment Amount = Outstanding Amount,Set Čiastka platby = dlžnej čiastky
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +53,Variance,Odchylka
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +130,Indirect Income,Nepřímé příjmy
+apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Odchylka
 ,Company Name,Názov spoločnosti
 DocType: SMS Center,Total Message(s),Celkem zpráv (y)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +675,Select Item for Transfer,Vybrať položku pre prevod
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +757,Select Item for Transfer,Vybrať položku pre prevod
 DocType: Purchase Invoice,Additional Discount Percentage,Ďalšie zľavy Percento
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Zobraziť zoznam všetkých videí nápovedy
 DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Vyberte účet šéf banky, kde byla uložena kontrola."
@@ -843,280 +783,263 @@
 						Please enter a valid Invoice","Riadok {0}: faktúra {1} je neplatná, to by mohlo byť zrušené / neexistuje. \ Zadajte platnú faktúru"
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Platba na prodejní / nákupní objednávce by měly být vždy označeny jako předem
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +16,Chemical,Chemický
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +681,All items have already been transferred for this Production Order.,Všechny položky již byly převedeny na výrobu tohoto řádu.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +686,All items have already been transferred for this Production Order.,Všechny položky již byly převedeny na výrobu tohoto řádu.
 DocType: Process Payroll,Select Payroll Year and Month,Vyberte Payroll rok a mesiac
 DocType: Workstation,Electricity Cost,Cena elektřiny
 DocType: HR Settings,Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin
-,Employee Holiday Attendance,Zamestnanec Holiday Účasť
 DocType: Opportunity,Walk In,Vejít
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +65,Stock Entries,Sklad Príspevky
-DocType: Item,Inspection Criteria,Inspekční Kritéria
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +113,Stock Entries,Sklad Príspevky
+DocType: Item,Inspection Criteria,Inšpekčné kritéria
 apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +12,Transfered,Prevedené
-apps/erpnext/erpnext/public/js/setup_wizard.js +140,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.)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +156,White,Biela
+apps/erpnext/erpnext/public/js/setup_wizard.js +163,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.)
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +165,White,Biela
 DocType: SMS Center,All Lead (Open),Všetky Iniciatívy (Otvorené)
 DocType: Purchase Invoice,Get Advances Paid,Získejte zaplacené zálohy
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +598,Make ,Dělat
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +678,Make ,Urobiť
 DocType: Journal Entry,Total Amount in Words,Celková částka slovy
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,"Došlo k chybě. Jedním z důvodů by mohlo být pravděpodobné, že jste uložili formulář. Obraťte se prosím na support@erpnext.com Pokud problém přetrvává."
 apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Môj košík
-apps/erpnext/erpnext/controllers/selling_controller.py +150,Order Type must be one of {0},Typ objednávky musí být jedním z {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +154,Order Type must be one of {0},Typ objednávky musí být jedním z {0}
 DocType: Lead,Next Contact Date,Další Kontakt Datum
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +35,Opening Qty,Otevření POČET
 DocType: Holiday List,Holiday List Name,Názov zoznamu sviatkov
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +168,Stock Options,Akciové opcie
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +177,Stock Options,Akciové opcie
 DocType: Journal Entry Account,Expense Claim,Hrazení nákladů
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +49,Do you really want to restore this scrapped asset?,Naozaj chcete obnoviť tento vyradený aktívum?
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +181,Qty for {0},Množství pro {0}
+apps/erpnext/erpnext/accounts/doctype/asset/asset.js +211,Do you really want to restore this scrapped asset?,Naozaj chcete obnoviť tento vyradený aktívum?
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +237,Qty for {0},Množství pro {0}
 DocType: Leave Application,Leave Application,Leave Application
 apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Nechte přidělení nástroj
 DocType: Leave Block List,Leave Block List Dates,Nechte Block List termíny
-DocType: Company,If Monthly Budget Exceeded (for expense account),Ak Mesačný rozpočet prekročený (pre výdavkového účtu)
 DocType: Workstation,Net Hour Rate,Net Hour Rate
 DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Přistál Náklady doklad o koupi
 DocType: Company,Default Terms,Východiskové podmienky
-DocType: Features Setup,"If checked, only Description, Quantity, Rate and Amount are shown in print of Item table. Any extra field is shown under 'Description' column.","Ak je zaškrtnuté, len opis, množstvo, percentuálne podiely a sumy sú uvedené v tlačenej podobe tabuľky položky. Akékoľvek ďalšie poľa je zobrazený v stĺpci &quot;Opis&quot;."
 DocType: Packing Slip Item,Packing Slip Item,Balení Slip Item
-DocType: POS Profile,Cash/Bank Account,Hotovostný / Bankový účet
+DocType: Purchase Invoice,Cash/Bank Account,Hotovostný / Bankový účet
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +70,Removed items with no change in quantity or value.,Odstránené položky bez zmeny množstva alebo hodnoty.
 DocType: Delivery Note,Delivery To,Doručení do
-apps/erpnext/erpnext/stock/doctype/item/item.py +552,Attribute table is mandatory,Atribút tabuľka je povinné
+apps/erpnext/erpnext/stock/doctype/item/item.py +632,Attribute table is mandatory,Atribút tabuľka je povinné
 DocType: Production Planning Tool,Get Sales Orders,Získat Prodejní objednávky
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +64,{0} can not be negative,{0} nemôže byť záporné
-apps/erpnext/erpnext/public/js/pos/pos.html +28,Discount,Sleva
-DocType: Features Setup,Purchase Discounts,Nákup Slevy
+apps/erpnext/erpnext/public/js/pos/pos.html +29,Discount,Sleva
 DocType: Workstation,Wages,Mzdy
-DocType: Time Log,Will be updated only if Time Log is 'Billable',"Bude aktualizovaná iba v prípade, Time Log je &quot;Fakturovateľná&quot;"
 DocType: Project,Internal,Interní
 DocType: Task,Urgent,Naléhavý
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +97,Please specify a valid Row ID for row {0} in table {1},Zadajte platný riadok ID riadku tabuľky {0} {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +113,Please specify a valid Row ID for row {0} in table {1},Zadajte platný riadok ID riadku tabuľky {0} {1}
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Prejdite na plochu a začnite používať ERPNext
 DocType: Item,Manufacturer,Výrobce
 DocType: Landed Cost Item,Purchase Receipt Item,Položka příjemky
 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,Prodejní Částka
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +80,Time Logs,Čas Záznamy
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +125,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Jste Expense schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +115,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Jste Expense schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
 DocType: Serial No,Creation Document No,Tvorba dokument č
 DocType: Issue,Issue,Problém
 DocType: Asset,Scrapped,zošrotovaný
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account does not match with Company,Účet nezodpovedá Company
-apps/erpnext/erpnext/config/stock.py +191,"Attributes for Item Variants. e.g Size, Color etc.","Atributy pro položky varianty. například velikost, barva atd."
+apps/erpnext/erpnext/config/stock.py +190,"Attributes for Item Variants. e.g Size, Color etc.","Atributy pro položky varianty. například velikost, barva atd."
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +39,WIP Warehouse,WIP Warehouse
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +185,Serial No {0} is under maintenance contract upto {1},Pořadové číslo {0} je na základě smlouvy o údržbě aľ {1}
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +194,Serial No {0} is under maintenance contract upto {1},Pořadové číslo {0} je na základě smlouvy o údržbě aľ {1}
 apps/erpnext/erpnext/config/hr.py +35,Recruitment,nábor
 DocType: BOM Operation,Operation,Operace
 DocType: Lead,Organization Name,Názov organizácie
 DocType: Tax Rule,Shipping State,Prepravné State
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,"Položka musí být přidány pomocí ""získat předměty z kupní příjmy"" tlačítkem"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Sales Expenses,Prodejní náklady
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +106,Standard Buying,Standardní Nakupování
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +62,Item must be added using 'Get Items from Purchase Receipts' button,"Položka musí být přidány pomocí ""získat předměty z kupní příjmy"" tlačítkem"
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +115,Sales Expenses,Prodejní náklady
+apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standardní Nakupování
 DocType: GL Entry,Against,Proti
 DocType: Item,Default Selling Cost Center,Výchozí Center Prodejní cena
 DocType: Sales Partner,Implementation Partner,Implementačního partnera
-apps/erpnext/erpnext/controllers/selling_controller.py +227,Sales Order {0} is {1},Predajné objednávky {0} {1}
+apps/erpnext/erpnext/controllers/selling_controller.py +231,Sales Order {0} is {1},Predajné objednávky {0} {1}
 DocType: Opportunity,Contact Info,Kontaktní informace
-apps/erpnext/erpnext/config/stock.py +300,Making Stock Entries,Tvorba prírastkov zásob
+apps/erpnext/erpnext/config/stock.py +299,Making Stock Entries,Tvorba prírastkov zásob
 DocType: Packing Slip,Net Weight UOM,Čistá hmotnosť MJ
 DocType: Item,Default Supplier,Výchozí Dodavatel
 DocType: Manufacturing Settings,Over Production Allowance Percentage,Nad výrobou Percento príspevkoch
 DocType: Shipping Rule Condition,Shipping Rule Condition,Přepravní Pravidlo Podmínka
-DocType: Features Setup,Miscelleneous,Miscelleneous
 DocType: Holiday List,Get Weekly Off Dates,Získejte týdenní Off termíny
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +30,End Date can not be less than Start Date,Datum ukončení nesmí být menší než data zahájení
 DocType: Sales Person,Select company name first.,"Prosím, vyberte najprv názov spoločnosti"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +145,Dr,Dr
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +155,Dr,Dr
 apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Ponuky od Dodávateľov.
-apps/erpnext/erpnext/controllers/selling_controller.py +21,To {0} | {1} {2},Chcete-li {0} | {1} {2}
-DocType: Time Log Batch,updated via Time Logs,aktualizovať cez čas Záznamy
+apps/erpnext/erpnext/controllers/selling_controller.py +22,To {0} | {1} {2},Chcete-li {0} | {1} {2}
+DocType: Timesheet,updated via Time Logs,aktualizovať cez čas Záznamy
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Průměrný věk
 DocType: Opportunity,Your sales person who will contact the customer in future,"Váš obchodní zástupce, který bude kontaktovat zákazníka v budoucnu"
-apps/erpnext/erpnext/public/js/setup_wizard.js +235,List a few of your suppliers. They could be organizations or individuals.,"Napíšte niekoľkých svojich dodávateľov. Môžu to byť organizácie, ale aj jednotlivci."
+apps/erpnext/erpnext/public/js/setup_wizard.js +261,List a few of your suppliers. They could be organizations or individuals.,"Napíšte niekoľkých svojich dodávateľov. Môžu to byť organizácie, ale aj jednotlivci."
 DocType: Company,Default Currency,Predvolená mena
 DocType: Contact,Enter designation of this Contact,Zadejte označení této Kontakt
 DocType: Expense Claim,From Employee,Od Zaměstnance
-apps/erpnext/erpnext/controllers/accounts_controller.py +347,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornění: Systém nebude kontrolovat nadfakturace, protože částka za položku na {1} je nula {0}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +400,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornění: Systém nebude kontrolovat nadfakturace, protože částka za položku na {1} je nula {0}"
 DocType: Journal Entry,Make Difference Entry,Učinit vstup Rozdíl
 DocType: Upload Attendance,Attendance From Date,Účast Datum od
 DocType: Appraisal Template Goal,Key Performance Area,Key Performance Area
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +54,Transportation,Doprava
 apps/erpnext/erpnext/hr/report/monthly_salary_register/monthly_salary_register.py +67, and year: ,a rok:
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +191,{0} {1} must be submitted,{0} {1} musí být odeslaný
 DocType: Email Digest,Annual Expense,Ročná Expense
 DocType: SMS Center,Total Characters,Celkový počet znaků
-apps/erpnext/erpnext/controllers/buying_controller.py +131,Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +156,Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
 DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detail
 DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Platba Odsouhlasení faktury
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Příspěvek%
-DocType: Item,website page link,webové stránky odkaz na stránku
 DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registrace firmy čísla pro váš odkaz. Daňové čísla atd
 DocType: Sales Partner,Distributor,Distributor
 DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Nákupní košík Shipping Rule
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +208,Production Order {0} must be cancelled before cancelling this Sales Order,Výrobní zakázka {0} musí být zrušena před zrušením této prodejní objednávky
-apps/erpnext/erpnext/public/js/controllers/transaction.js +941,Please set 'Apply Additional Discount On',Prosím nastavte na &quot;Použiť dodatočnú zľavu On&quot;
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +211,Production Order {0} must be cancelled before cancelling this Sales Order,Výrobní zakázka {0} musí být zrušena před zrušením této prodejní objednávky
+apps/erpnext/erpnext/public/js/controllers/transaction.js +62,Please set 'Apply Additional Discount On',Prosím nastavte na &quot;Použiť dodatočnú zľavu On&quot;
 ,Ordered Items To Be Billed,Objednané zboží fakturovaných
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +24,From Range has to be less than To Range,"Z rozsahu, musí byť nižšia ako na Range"
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +21,Select Time Logs and Submit to create a new Sales Invoice.,Vyberte Time protokolů a předložit k vytvoření nové prodejní faktury.
+apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +39,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 +144,Project Collaboration Invitation,Projekt spolupráce Pozvánka
+apps/erpnext/erpnext/projects/doctype/project/project.py +151,Project Collaboration Invitation,Projekt spolupráce Pozvánka
 DocType: Salary Slip,Deductions,Odpočty
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +23,This Time Log Batch has been billed.,To Batch Time Log bylo účtováno.
+DocType: Purchase Invoice,Start date of current invoice's period,Datum období současného faktury je Začátek
 DocType: Salary Slip,Leave Without Pay,Nechat bez nároku na mzdu
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +270,Capacity Planning Error,Plánovanie kapacít Chyba
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +323,Capacity Planning Error,Plánovanie kapacít Chyba
 ,Trial Balance for Party,Trial váhy pre stranu
 DocType: Lead,Consultant,Konzultant
 DocType: Salary Slip,Earnings,Výdělek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Finished Item {0} must be entered for Manufacture type entry,Dokončené Položka {0} musí byť zadaný pre vstup typu Výroba
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +362,Finished Item {0} must be entered for Manufacture type entry,Dokončené Položka {0} musí byť zadaný pre vstup typu Výroba
 apps/erpnext/erpnext/config/learn.py +92,Opening Accounting Balance,Otvorenie účtovníctva Balance
 DocType: Sales Invoice Advance,Sales Invoice Advance,Prodejní faktury Advance
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +476,Nothing to request,Nic požadovat
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +483,Nothing to request,Nic požadovat
 apps/erpnext/erpnext/projects/doctype/task/task.py +38,'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/install_fixtures.py +75,Management,Řízení
-apps/erpnext/erpnext/config/projects.py +45,Types of activities for Time Sheets,Typy činností pro Time listy
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +75,Management,Manažment
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +52,Either debit or credit amount is required for {0},Buď debetní nebo kreditní částka je vyžadována pro {0}
 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"""
 DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Čistá Pay (slovy) budou viditelné, jakmile uložíte výplatní pásce."
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +154,Blue,Modrý
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +163,Blue,Modrý
 DocType: Purchase Invoice,Is Return,Je Return
 DocType: Price List Country,Price List Country,Cenník Krajina
-apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +123,Further nodes can be only created under 'Group' type nodes,"Další uzly mohou být pouze vytvořena v uzlech typu ""skupiny"""
 apps/erpnext/erpnext/utilities/doctype/contact/contact.py +69,Please set Email ID,Prosím nastavte e-mail ID
 DocType: Item,UOMs,Merné Jednotky
-apps/erpnext/erpnext/stock/utils.py +171,{0} valid serial nos for Item {1},{0} platné sériové čísla pre položky {1}
+apps/erpnext/erpnext/stock/utils.py +181,{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 +57,Item Code cannot be changed for Serial No.,Kód položky nemůže být změněn pro Serial No.
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +22,POS Profile {0} already created for user: {1} and company {2},POS Profile {0} už vytvorili pre užívateľov: {1} a spoločnosť {2}
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +23,POS Profile {0} already created for user: {1} and company {2},POS Profile {0} už vytvorili pre užívateľov: {1} a spoločnosť {2}
 DocType: Purchase Order Item,UOM Conversion Factor,Faktor konverzie MJ
 DocType: Stock Settings,Default Item Group,Výchozí bod Group
 apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Databáze dodavatelů.
 DocType: Account,Balance Sheet,Rozvaha
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +623,Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +642,Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
 DocType: Opportunity,Your sales person will get a reminder on this date to contact the customer,"Váš obchodní zástupce dostane upomínku na tento den, aby kontaktoval zákazníka"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +212,"Further accounts can be made under Groups, but entries can be made against non-Groups","Ďalšie účty môžu byť vyrobené v rámci skupiny, ale údaje je možné proti non-skupín"
-apps/erpnext/erpnext/config/hr.py +120,Tax and other salary deductions.,Daňové a jiné platové srážky.
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,"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
 DocType: Email Digest,Payables,Závazky
 DocType: Account,Warehouse,Sklad
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +83,Row #{0}: Rejected Qty can not be entered in Purchase Return,Riadok # {0}: zamietnutie Množstvo nemôže byť zapísaný do kúpnej Návrat
+apps/erpnext/erpnext/controllers/buying_controller.py +289,Row #{0}: Rejected Qty can not be entered in Purchase Return,Riadok # {0}: zamietnutie Množstvo nemôže byť zapísaný do kúpnej Návrat
 ,Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci
 DocType: Purchase Invoice Item,Net Rate,Čistá miera
 DocType: Purchase Invoice Item,Purchase Invoice Item,Položka přijaté faktury
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +50,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Sériové Ledger Přihlášky a GL položky jsou zveřejňována pro vybrané Nákupní Příjmy
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +57,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Sériové Ledger Přihlášky a GL položky jsou zveřejňována pro vybrané Nákupní Příjmy
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Položka 1
 DocType: Holiday,Holiday,Dovolená
 DocType: Leave Control Panel,Leave blank if considered for all branches,"Ponechte prázdné, pokud se to považuje za všechny obory"
-,Daily Time Log Summary,Denní doba prihlásenia - súhrn
 apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-forma sa nevzťahuje na faktúre: {0}
 DocType: Payment Reconciliation,Unreconciled Payment Details,Smířit platbě
 DocType: Global Defaults,Current Fiscal Year,Aktuální fiskální rok
 DocType: Global Defaults,Disable Rounded Total,Zakázat Zaoblený Celkem
 DocType: Lead,Call,Volání
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +410,'Entries' cannot be empty,"""Položky"" nemôžu býť prázdne"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +417,'Entries' cannot be empty,"""Položky"" nemôžu býť prázdne"
 apps/erpnext/erpnext/utilities/transaction_base.py +78,Duplicate row {0} with same {1},Duplicitný riadok {0} s rovnakým {1}
 ,Trial Balance,Trial Balance
-apps/erpnext/erpnext/config/hr.py +242,Setting up Employees,Nastavenia pre modul Zamestnanci
-apps/erpnext/erpnext/public/js/feature_setup.js +220,"Grid ""","Grid """
+apps/erpnext/erpnext/config/hr.py +238,Setting up Employees,Nastavenia pre modul Zamestnanci
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +150,Please select prefix first,"Prosím, vyberte první prefix"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +138,Research,Výzkum
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +147,Research,Výzkum
 DocType: Maintenance Visit Purpose,Work Done,Odvedenou práci
 apps/erpnext/erpnext/controllers/item_variant.py +25,Please specify at least one attribute in the Attributes table,Uveďte aspoň jeden atribút v tabuľke atribúty
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +33,Item {0} must be a non-stock item,Item {0} musí byť non-skladová položka
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +43,Item {0} must be a non-stock item,Item {0} musí byť non-skladová položka
 DocType: Contact,User ID,User ID
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +131,View Ledger,View Ledger
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Nejstarší
-apps/erpnext/erpnext/stock/doctype/item/item.py +436,"An Item Group exists with same name, please change the item name or rename the item group","Položka Group existuje se stejným názvem, prosím, změnit název položky nebo přejmenovat skupinu položek"
-DocType: Production Order,Manufacture against Sales Order,Výroba na odběratele
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +412,Rest Of The World,Zbytek světa
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +83,The Item {0} cannot have Batch,Položka {0} nemůže mít dávku
+apps/erpnext/erpnext/stock/doctype/item/item.py +501,"An Item Group exists with same name, please change the item name or rename the item group","Položka Group existuje se stejným názvem, prosím, změnit název položky nebo přejmenovat skupinu položek"
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +433,Rest Of The World,Zbytek světa
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,The Item {0} cannot have Batch,Položka {0} nemůže mít dávku
 ,Budget Variance Report,Rozpočet Odchylka Report
 DocType: Salary Slip,Gross Pay,Hrubé mzdy
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +189,Dividends Paid,Dividendy platené
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Dividends Paid,Dividendy platené
 apps/erpnext/erpnext/public/js/controllers/stock_controller.js +40,Accounting Ledger,Účtovné Ledger
 DocType: Stock Reconciliation,Difference Amount,Rozdiel Suma
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +195,Retained Earnings,Nerozdelený zisk
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Retained Earnings,Nerozdelený zisk
 DocType: BOM Item,Item Description,Položka Popis
-DocType: Payment Tool,Payment Mode,Způsob platby
 DocType: Purchase Invoice,Is Recurring,Je Opakující
-DocType: Purchase Order,Supplied Items,Dodávané položky
+DocType: Purchase Invoice,Supplied Items,Dodávané položky
 DocType: Production Order,Qty To Manufacture,Množství K výrobě
 DocType: Buying Settings,Maintain same rate throughout purchase cycle,Udržovat stejnou sazbu po celou kupní cyklu
 DocType: Opportunity Item,Opportunity Item,Položka Příležitosti
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +64,Temporary Opening,Dočasné Otvorenie
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +70,Temporary Opening,Dočasné Otvorenie
 ,Employee Leave Balance,Zaměstnanec Leave Balance
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +127,Balance for Account {0} must always be {1},Zůstatek na účtě {0} musí být vždy {1}
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +131,Balance for Account {0} must always be {1},Zůstatek na účtě {0} musí být vždy {1}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +179,Valuation Rate required for Item in row {0},Ocenenie Miera potrebná pre položku v riadku {0}
 DocType: Address,Address Type,Typ adresy
-DocType: Purchase Receipt,Rejected Warehouse,Zamítnuto Warehouse
+DocType: Purchase Invoice,Rejected Warehouse,Zamítnuto Warehouse
 DocType: GL Entry,Against Voucher,Proti poukazu
 DocType: Item,Default Buying Cost Center,Výchozí Center Nákup Cost
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Ak chcete získať to najlepšie z ERPNext, odporúčame vám nejaký čas venovať týmto videám."
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +33,Item {0} must be Sales Item,Položka {0} musí být Sales Item
-apps/erpnext/erpnext/public/js/controllers/taxes_and_totals.js +55, to ,k
+apps/erpnext/erpnext/accounts/page/pos/pos.js +87, to ,k
 DocType: Item,Lead Time in days,Vek Obchodnej iniciatívy v dňoch
 ,Accounts Payable Summary,Splatné účty Shrnutí
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +192,Not authorized to edit frozen Account {0},Není povoleno upravovat zmrazený účet {0}
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Not authorized to edit frozen Account {0},Není povoleno upravovat zmrazený účet {0}
 DocType: Journal Entry,Get Outstanding Invoices,Získat neuhrazených faktur
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +65,Sales Order {0} is not valid,Prodejní objednávky {0} není platný
-apps/erpnext/erpnext/setup/doctype/company/company.py +168,"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +126,"The total Issue / Transfer quantity {0} in Material Request {1}  \
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +62,Sales Order {0} is not valid,Prodejní objednávky {0} není platný
+apps/erpnext/erpnext/setup/doctype/company/company.py +182,"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +139,"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/install_fixtures.py +145,Small,Malý
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +154,Small,Malý
 DocType: Employee,Employee Number,Počet zaměstnanců
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +65,Case No(s) already in use. Try from Case No {0},Případ číslo (čísla) již v provozu. Zkuste se věc č {0}
 ,Invoiced Amount (Exculsive Tax),Fakturovaná částka (bez daně)
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Položka 2
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +67,Account head {0} created,Hlava účtu {0} vytvořil
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +153,Green,Zelená
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Account head {0} created,Hlava účtu {0} vytvořil
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +162,Green,Zelená
 DocType: Item,Auto re-order,Auto re-order
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Celkem Dosažená
 DocType: Employee,Place of Issue,Místo vydání
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +59,Contract,Smlouva
 DocType: Email Digest,Add Quote,Pridať ponuku
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +493,UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktor potřebný k nerozpuštěných: {0} v bodě: {1}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +86,Indirect Expenses,Nepřímé náklady
-apps/erpnext/erpnext/controllers/selling_controller.py +163,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +498,UOM coversion factor required for UOM: {0} in Item: {1},Koeficient prepočtu MJ je potrebný k MJ: {0} v bode: {1}
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +90,Indirect Expenses,Nepřímé náklady
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +80,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Poľnohospodárstvo
-apps/erpnext/erpnext/public/js/setup_wizard.js +257,Your Products or Services,Vaše Produkty alebo Služby
+apps/erpnext/erpnext/public/js/setup_wizard.js +283,Your Products or Services,Vaše Produkty alebo Služby
 DocType: Mode of Payment,Mode of Payment,Způsob platby
-apps/erpnext/erpnext/stock/doctype/item/item.py +126,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
+apps/erpnext/erpnext/stock/doctype/item/item.py +175,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
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +31,This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.
 DocType: Journal Entry Account,Purchase Order,Vydaná objednávka
 DocType: Warehouse,Warehouse Contact Info,Sklad Kontaktní informace
+DocType: Purchase Invoice,Recurring Type,Opakující se Typ
 DocType: Address,City/Town,Město / Město
 DocType: Address,Is Your Company Address,Je vaša firma adresa
 DocType: Email Digest,Annual Income,Ročný príjem
 DocType: Serial No,Serial No Details,Serial No Podrobnosti
 DocType: Purchase Invoice Item,Item Tax Rate,Sazba daně položky
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,"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/sales_invoice/sales_invoice.py +486,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
-apps/erpnext/erpnext/stock/get_item_details.py +142,Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +464,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
+apps/erpnext/erpnext/stock/get_item_details.py +133,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 +41,Capital Equipments,Kapitálové Vybavení
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +31,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","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."
 DocType: Hub Settings,Seller Website,Prodejce Website
-apps/erpnext/erpnext/controllers/selling_controller.py +143,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +113,Production Order status is {0},Stav výrobní zakázka je {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +147,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +110,Production Order status is {0},Stav výrobní zakázka je {0}
 DocType: Appraisal Goal,Goal,Cieľ
 DocType: Sales Invoice Item,Edit Description,Upraviť popis
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +331,Expected Delivery Date is lesser than Planned Start Date.,Očakávané dátum dodania je menšia ako plánovaný dátum začatia.
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +617,For Supplier,Pro Dodavatele
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +704,For Supplier,Pro Dodavatele
 DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Nastavení typu účtu pomáhá při výběru tohoto účtu v transakcích.
 DocType: Purchase Invoice,Grand Total (Company Currency),Celkový součet (Měna společnosti)
 apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Nenašiel žiadnu položku s názvom {0}
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Celkem Odchozí
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +48,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Tam může být pouze jeden Shipping Rule Podmínka s 0 nebo prázdnou hodnotu pro ""na hodnotu"""
 DocType: Authorization Rule,Transaction,Transakce
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +45,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/accounts/doctype/cost_center/cost_center.js +27,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.
 DocType: Item,Website Item Groups,Webové stránky skupiny položek
 DocType: Purchase Invoice,Total (Company Currency),Total (Company meny)
-apps/erpnext/erpnext/stock/utils.py +166,Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou
+apps/erpnext/erpnext/stock/utils.py +176,Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou
 DocType: Depreciation Schedule,Journal Entry,Zápis do deníku
 DocType: Workstation,Workstation Name,Meno pracovnej stanice
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,E-mail Digest:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +442,BOM {0} does not belong to Item {1},BOM {0} nepatří k bodu {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +445,BOM {0} does not belong to Item {1},BOM {0} nepatří k bodu {1}
 DocType: Sales Partner,Target Distribution,Target Distribution
 DocType: Salary Slip,Bank Account No.,Číslo bankového účtu
 DocType: Naming Series,This is the number of the last created transaction with this prefix,To je číslo poslední vytvořené transakci s tímto prefixem
 DocType: Quality Inspection Reading,Reading 8,Čtení 8
 DocType: Sales Partner,Agent,Agent
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +74,"Total {0} for all items is zero, may you should change 'Distribute Charges Based On'","Celkom {0} pre všetky položky je nula, môžete mali zmeniť &quot;Distribuovať poplatkov na základe&quot;"
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +75,"Total {0} for all items is zero, may you should change 'Distribute Charges Based On'","Celkom {0} pre všetky položky je nula, môžete mali zmeniť &quot;Distribuovať poplatkov na základe&quot;"
 DocType: Purchase Invoice,Taxes and Charges Calculation,Daně a poplatky výpočet
 DocType: BOM Operation,Workstation,pracovna stanica
 DocType: Request for Quotation Supplier,Request for Quotation Supplier,Žiadosť o cenovú ponuku dodávateľa
@@ -1129,65 +1052,58 @@
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +79,You need to enable Shopping Cart,Musíte povolit Nákupní košík
 DocType: Appraisal Template Goal,Appraisal Template Goal,Posouzení Template Goal
 DocType: Salary Slip,Earning,Získávání
-DocType: Payment Tool,Party Account Currency,Party Mena účtu
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +46,Current Value After Depreciation must be less than equal to {0},Aktuálna hodnota po odpisoch musí byť menší ako rovná {0}
+DocType: Purchase Invoice,Party Account Currency,Party Mena účtu
 ,BOM Browser,BOM Browser
 DocType: Purchase Taxes and Charges,Add or Deduct,Přidat nebo Odečíst
-DocType: Company,If Yearly Budget Exceeded (for expense account),Ak Ročný rozpočet prekročený (pre výdavkového účtu)
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +81,Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +167,Against Journal Entry {0} is already adjusted against some other voucher,Proti věstníku Entry {0} je již nastavena proti jiným poukaz
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +171,Against Journal Entry {0} is already adjusted against some other voucher,Proti věstníku Entry {0} je již nastavena proti jiným poukaz
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Celková hodnota objednávky
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +38,Food,Jídlo
+apps/erpnext/erpnext/demo/setup_data.py +345,Food,Jídlo
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Stárnutí Rozsah 3
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +136,You can make a time log only against a submitted production order,Můžete udělat časový záznam pouze proti předložené výrobní objednávce
 DocType: Maintenance Schedule Item,No of Visits,Počet návštěv
-apps/erpnext/erpnext/config/crm.py +68,"Newsletters to contacts, leads.",Newsletter kontaktom a obchodným iniciatívam
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},"Mena záverečného účtu, musí byť {0}"
 apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Súčet bodov za všetkých cieľov by malo byť 100. Je {0}
 DocType: Project,Start and End Dates,Dátum začatia a ukončenia
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +375,Operations cannot be left blank.,Operace nemůže být prázdné.
 ,Delivered Items To Be Billed,Dodávaných výrobků fakturovaných
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Warehouse nemůže být změněn pro Serial No.
 DocType: Authorization Rule,Average Discount,Průměrná sleva
 DocType: Address,Utilities,Utilities
 DocType: Purchase Invoice Item,Accounting,Účtovníctvo
-DocType: Features Setup,Features Setup,Nastavení Funkcí
 DocType: Asset,Depreciation Schedules,odpisy Plány
-DocType: Item,Is Service Item,Je Service Item
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +84,Application period cannot be outside leave allocation period,Obdobie podávania žiadostí nemôže byť alokačné obdobie vonku voľno
 DocType: Activity Cost,Projects,Projekty
 DocType: Payment Request,Transaction Currency,transakčné mena
 apps/erpnext/erpnext/controllers/buying_controller.py +24,From {0} | {1} {2},Od {0} | {1} {2}
-DocType: BOM Operation,Operation Description,Operace Popis
+DocType: Production Order Operation,Operation Description,Operace Popis
 DocType: Item,Will also apply to variants,Bude sa vzťahovať aj na varianty
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +32,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Nelze měnit Fiskální rok Datum zahájení a fiskální rok datum ukončení, jakmile fiskální rok se uloží."
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Nelze měnit Fiskální rok Datum zahájení a fiskální rok datum ukončení, jakmile fiskální rok se uloží."
 DocType: Quotation,Shopping Cart,Nákupní vozík
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Avg Daily Odchozí
 DocType: Pricing Rule,Campaign,Kampaň
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +28,Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto"""
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +29,Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto"""
 DocType: Purchase Invoice,Contact Person,Kontaktná osoba
 apps/erpnext/erpnext/projects/doctype/task/task.py +35,'Expected Start Date' can not be greater than 'Expected End Date',"""Očakávaný Dátum Začiatku"" nemôže byť väčší ako ""Očakávaný Dátum Ukončenia"""
 DocType: Holiday List,Holidays,Prázdniny
 DocType: Sales Order Item,Planned Quantity,Plánované Množství
 DocType: Purchase Invoice Item,Item Tax Amount,Částka Daně Položky
 DocType: Item,Maintain Stock,Udržiavať Zásoby
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +210,Stock Entries already created for Production Order ,Fotky Položky již vytvořené pro výrobní zakázku
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +209,Stock Entries already created for Production Order ,Fotky Položky již vytvořené pro výrobní zakázku
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +31,Net Change in Fixed Asset,Čistá zmena v stálych aktív
 DocType: Leave Control Panel,Leave blank if considered for all designations,"Ponechte prázdné, pokud se to považuje za všechny označení"
-apps/erpnext/erpnext/controllers/accounts_controller.py +539,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/production_order/production_order.js +182,Max: {0},Max: {0}
-apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +16,From Datetime,Od datetime
+apps/erpnext/erpnext/controllers/accounts_controller.py +620,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/production_order/production_order.js +238,Max: {0},Max: {0}
+apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +15,From Datetime,Od datetime
 DocType: Email Digest,For Company,Pre spoločnosť
 apps/erpnext/erpnext/config/support.py +17,Communication log.,Komunikační protokol.
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Buying Amount,Nákup Částka
 DocType: Sales Invoice,Shipping Address Name,Přepravní Adresa Název
-apps/erpnext/erpnext/accounts/doctype/account/account.js +50,Chart of Accounts,Diagram účtů
+apps/erpnext/erpnext/accounts/doctype/account/account.js +49,Chart of Accounts,Diagram účtů
 DocType: Material Request,Terms and Conditions Content,Podmínky Content
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +475,cannot be greater than 100,nemôže byť väčšie ako 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +592,Item {0} is not a stock Item,Položka {0} není skladem
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +509,cannot be greater than 100,nemôže byť väčšie ako 100
+apps/erpnext/erpnext/stock/doctype/item/item.py +677,Item {0} is not a stock Item,Položka {0} není skladem
 DocType: Maintenance Visit,Unscheduled,Neplánovaná
 DocType: Employee,Owned,Vlastník
-DocType: Salary Slip Deduction,Depends on Leave Without Pay,Závisí na dovolenke bez nároku na mzdu
+DocType: Salary Detail,Depends on Leave Without Pay,Závisí na dovolenke bez nároku na mzdu
 DocType: Pricing Rule,"Higher the number, higher the priority","Vyšší číslo, vyšší priorita"
 ,Purchase Invoice Trends,Trendy přijatách faktur
 DocType: Employee,Better Prospects,Lepší vyhlídky
@@ -1203,256 +1119,235 @@
 DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
 Used for Taxes and Charges","Tax detail tabulka staženy z položky pána jako řetězec a uložené v této oblasti.
  Používá se daní a poplatků"
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +156,Employee cannot report to himself.,Zaměstnanec nemůže odpovídat sám sobě.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +152,Employee cannot report to himself.,Zaměstnanec nemůže odpovídat sám sobě.
 DocType: Account,"If the account is frozen, entries are allowed to restricted users.","V případě, že účet je zamrzlý, položky mohou omezeným uživatelům."
 DocType: Email Digest,Bank Balance,Bank Balance
-apps/erpnext/erpnext/controllers/accounts_controller.py +460,Accounting Entry for {0}: {1} can only be made in currency: {2},Účtovný záznam pre {0}: {1} môžu vykonávať len v mene: {2}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +44,No active Salary Structure found for employee {0} and the month,Žiadny aktívny Štruktúra Plat nájdených pre zamestnancov {0} a mesiac
+apps/erpnext/erpnext/accounts/party.py +234,Accounting Entry for {0}: {1} can only be made in currency: {2},Účtovný záznam pre {0}: {1} môžu vykonávať len v mene: {2}
 DocType: Job Opening,"Job profile, qualifications required etc.","Profil Job, požadované kvalifikace atd."
 DocType: Journal Entry Account,Account Balance,Zůstatek na účtu
-apps/erpnext/erpnext/config/accounts.py +175,Tax Rule for transactions.,Daňové Pravidlo pre transakcie.
+apps/erpnext/erpnext/config/accounts.py +174,Tax Rule for transactions.,Daňové Pravidlo pre transakcie.
 DocType: Rename Tool,Type of document to rename.,Typ dokumentu na premenovanie.
-apps/erpnext/erpnext/public/js/setup_wizard.js +276,We buy this Item,Táto položka sa kupuje
+apps/erpnext/erpnext/public/js/setup_wizard.js +302,We buy this Item,Táto položka sa kupuje
 DocType: Address,Billing,Fakturace
-DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Celkem Daně a poplatky (Company Měnové)
+DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Spolu dane a poplatky (v peňažnej mene firmy)
 DocType: Shipping Rule,Shipping Account,Přepravní účtu
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +43,Scheduled to send to {0} recipients,Plánované poslat na {0} příjemci
 DocType: Quality Inspection,Readings,Čtení
 DocType: Stock Entry,Total Additional Costs,Celkom Dodatočné náklady
-apps/erpnext/erpnext/public/js/setup_wizard.js +269,Sub Assemblies,Podsestavy
+apps/erpnext/erpnext/public/js/setup_wizard.js +295,Sub Assemblies,Podsestavy
 DocType: Asset,Asset Name,asset Name
 DocType: Shipping Rule Condition,To Value,Chcete-li hodnota
-DocType: Supplier,Stock Manager,Reklamný manažér
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +142,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +643,Packing Slip,Balení Slip
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +114,Office Rent,Pronájem kanceláře
-apps/erpnext/erpnext/config/setup.py +110,Setup SMS gateway settings,Nastavenie SMS brány
+DocType: Asset Movement,Stock Manager,Reklamný manažér
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +141,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +673,Packing Slip,Balení Slip
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +108,Office Rent,Pronájem kanceláře
+apps/erpnext/erpnext/config/setup.py +105,Setup SMS gateway settings,Nastavenie SMS brány
 apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,Request for quotation can be access by clicking following link,Žiadosť o cenovú ponuku môže byť prístup kliknutím na nasledujúci odkaz
-DocType: Asset,Number of Months in a Period,Počet mesiacov v období
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +60,Import Failed!,Import se nezdařil!
 apps/erpnext/erpnext/public/js/templates/address_list.html +21,No address added yet.,Žádná adresa přidán dosud.
 DocType: Workstation Working Hour,Workstation Working Hour,Pracovní stanice Pracovní Hour
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +83,Analyst,Analytik
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,Row {0}: Allocated amount {1} must be less than or equals to JV amount {2},"Řádek {0}: přidělené množství {1}, musí být menší než nebo se rovná hodnotě JV {2}"
 DocType: Item,Inventory,Inventář
-DocType: Features Setup,"To enable ""Point of Sale"" view",Ak chcete povoliť &quot;Point of Sale&quot; pohľadu
-apps/erpnext/erpnext/public/js/pos/pos.js +415,Payment cannot be made for empty cart,Platba nemůže být pro prázdný košík
 DocType: Item,Sales Details,Prodejní Podrobnosti
 DocType: Opportunity,With Items,S položkami
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,In Qty,V Množství
 DocType: Notification Control,Expense Claim Rejected,Uhrazení výdajů zamítnuto
 DocType: Item Attribute,Item Attribute,Položka Atribut
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +105,Government,Vláda
-apps/erpnext/erpnext/config/stock.py +290,Item Variants,Varianty Položky
+apps/erpnext/erpnext/config/stock.py +289,Item Variants,Varianty Položky
 DocType: Company,Services,Služby
-apps/erpnext/erpnext/accounts/report/financial_statements.py +198,Total ({0}),Celkem ({0})
 DocType: Cost Center,Parent Cost Center,Nadřazené Nákladové středisko
 DocType: Sales Invoice,Source,Zdroj
-apps/erpnext/erpnext/templates/pages/projects.html +57,Show closed,show uzavretý
+apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,show uzavretý
 DocType: Leave Type,Is Leave Without Pay,Je odísť bez Pay
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +129,No records found in the Payment table,Nalezené v tabulce platby Žádné záznamy
-apps/erpnext/erpnext/public/js/setup_wizard.js +39,Financial Year Start Date,Finanční rok Datum zahájení
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,No records found in the Payment table,Nalezené v tabulce platby Žádné záznamy
+apps/erpnext/erpnext/public/js/setup_wizard.js +60,Financial Year Start Date,Dátum začiatku finančného roku
 DocType: Employee External Work History,Total Experience,Celková zkušenost
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +261,Packing Slip(s) cancelled,Balení Slip (y) zrušeno
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +265,Packing Slip(s) cancelled,Balení Slip (y) zrušeno
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29,Cash Flow from Investing,Peňažný tok z investičných
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Nákladní a Spediční Poplatky
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +97,Freight and Forwarding Charges,Nákladní a Spediční Poplatky
 DocType: Item Group,Item Group Name,Položka Název skupiny
 apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Zaujatý
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +87,Transfer Materials for Manufacture,Přenos Materiály pro výrobu
 DocType: Pricing Rule,For Price List,Pro Ceník
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Executive Search
-apps/erpnext/erpnext/stock/stock_ledger.py +406,"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.","Cena při platbě za položku: {0} nebyl nalezen, který je povinen si účetní položka (náklady). Prosím, uveďte zboží Cena podle seznamu kupní cenou."
+apps/erpnext/erpnext/stock/stock_ledger.py +426,"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.","Cena při platbě za položku: {0} nebyl nalezen, který je povinen si účetní položka (náklady). Prosím, uveďte zboží Cena podle seznamu kupní cenou."
 DocType: Maintenance Schedule,Schedules,Plány
 DocType: Purchase Invoice Item,Net Amount,Čistá suma
 DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail No
 DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatočná zľava Suma (Mena Company)
-apps/erpnext/erpnext/accounts/doctype/account/account.js +8,Please create new account from Chart of Accounts.,"Prosím, vytvořte nový účet z grafu účtů."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +702,Maintenance Visit,Maintenance Visit
+apps/erpnext/erpnext/accounts/doctype/account/account.js +7,Please create new account from Chart of Accounts.,"Prosím, vytvořte nový účet z grafu účtů."
+DocType: Maintenance Visit,Maintenance Visit,Maintenance Visit
 DocType: Sales Invoice Item,Available Batch Qty at Warehouse,K dispozícii dávky Množstvo v sklade
-DocType: Time Log Batch Detail,Time Log Batch Detail,Time Log Batch Detail
 DocType: Landed Cost Voucher,Landed Cost Help,Přistálo Náklady Help
 DocType: Purchase Invoice,Select Shipping Address,Zvoliť adresu pre dodanie
 DocType: Leave Block List,Block Holidays on important days.,Blokové Dovolená na významných dnů.
 ,Accounts Receivable Summary,Pohledávky Shrnutí
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +194,Please set User ID field in an Employee record to set Employee Role,Prosím nastavte uživatelské ID pole v záznamu zaměstnanců nastavit role zaměstnance
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +198,Please set User ID field in an Employee record to set Employee Role,Prosím nastavte uživatelské ID pole v záznamu zaměstnanců nastavit role zaměstnance
 DocType: UOM,UOM Name,Názov Mernej Jednotky
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Výše příspěvku
 DocType: Purchase Invoice,Shipping Address,Shipping Address
 DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,"Tento nástroj vám pomůže aktualizovat nebo opravit množství a ocenění zásob v systému. To se obvykle používá k synchronizaci hodnot systému a to, co ve skutečnosti existuje ve vašich skladech."
 DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"Ve slovech budou viditelné, jakmile uložíte doručení poznámku."
-apps/erpnext/erpnext/config/stock.py +196,Brand master.,Master Značky
+apps/erpnext/erpnext/config/stock.py +195,Brand master.,Master Značky
 DocType: Sales Invoice Item,Brand Name,Jméno značky
 DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
-apps/erpnext/erpnext/public/js/setup_wizard.js +272,Box,Krabica
-apps/erpnext/erpnext/public/js/setup_wizard.js +14,The Organization,Organizácia
-DocType: Monthly Distribution,Monthly Distribution,Měsíční Distribution
+apps/erpnext/erpnext/public/js/setup_wizard.js +298,Box,Krabica
+apps/erpnext/erpnext/public/js/setup_wizard.js +36,The Organization,Organizácia
+DocType: Budget,Monthly Distribution,Měsíční Distribution
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Přijímač Seznam je prázdný. Prosím vytvořte přijímače Seznam
 DocType: Production Plan Sales Order,Production Plan Sales Order,Výrobní program prodejní objednávky
 DocType: Sales Partner,Sales Partner Target,Sales Partner Target
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +106,Accounting Entry for {0} can only be made in currency: {1},Účtovný záznam pre {0} možno vykonávať iba v mene: {1}
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +110,Accounting Entry for {0} can only be made in currency: {1},Účtovný záznam pre {0} možno vykonávať iba v mene: {1}
 DocType: Pricing Rule,Pricing Rule,Ceny Pravidlo
 apps/erpnext/erpnext/config/learn.py +202,Material Request to Purchase Order,Materiál Žiadosť o príkaze k nákupu
 DocType: Shopping Cart Settings,Payment Success URL,Platba Úspech URL
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +77,Row # {0}: Returned Item {1} does not exists in {2} {3},Riadok # {0}: vrátenej položky {1} neexistuje v {2} {3}
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +78,Row # {0}: Returned Item {1} does not exists in {2} {3},Riadok # {0}: vrátenej položky {1} neexistuje v {2} {3}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankové účty
 ,Bank Reconciliation Statement,Bank Odsouhlasení prohlášení
 DocType: Address,Lead Name,Meno Obchodnej iniciatívy
 ,POS,POS
-apps/erpnext/erpnext/config/stock.py +295,Opening Stock Balance,Otvorenie Sklad Balance
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +36,{0} must appear only once,{0} môže byť uvedené iba raz
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +334,Not allowed to tranfer more {0} than {1} against Purchase Order {2},"Nie je povolené, aby transfer viac {0} ako {1} proti objednanie {2}"
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +62,Leaves Allocated Successfully for {0},Listy Přidělené úspěšně za {0}
+apps/erpnext/erpnext/config/stock.py +294,Opening Stock Balance,Otvorenie Sklad Balance
+apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +51,{0} must appear only once,{0} môže byť uvedené iba raz
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +339,Not allowed to tranfer more {0} than {1} against Purchase Order {2},"Nie je povolené, aby transfer viac {0} ako {1} proti objednanie {2}"
+apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Listy Přidělené úspěšně za {0}
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +40,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 +540,Manufacturing Quantity is mandatory,Výrobní množství je povinné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +545,Manufacturing Quantity is mandatory,Výrobní množství je povinné
 DocType: Quality Inspection Reading,Reading 4,Čtení 4
-apps/erpnext/erpnext/config/hr.py +131,Claims for company expense.,Nároky na náklady firmy.
+apps/erpnext/erpnext/config/hr.py +127,Claims for company expense.,Nároky na náklady firmy.
 DocType: Company,Default Holiday List,Výchozí Holiday Seznam
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +168,Stock Liabilities,Stock Závazky
-DocType: Purchase Receipt,Supplier Warehouse,Dodavatel Warehouse
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +142,Stock Liabilities,Stock Závazky
+DocType: Purchase Invoice,Supplier Warehouse,Dodavatel Warehouse
 DocType: Opportunity,Contact Mobile No,Kontakt Mobil
 ,Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +120,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."
-DocType: Features Setup,To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Chcete-li sledovat položky pomocí čárového kódu. Budete mít možnost zadat položky dodacího listu a prodejní faktury snímáním čárového kódu položky.
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Znovu poslať e-mail Payment
-apps/erpnext/erpnext/config/selling.py +210,Other Reports,Ostatné správy
+apps/erpnext/erpnext/config/selling.py +206,Other Reports,Ostatné správy
 DocType: Dependent Task,Dependent Task,Závislý Task
-apps/erpnext/erpnext/stock/doctype/item/item.py +349,Conversion factor for default Unit of Measure must be 1 in row {0},"Konverzní faktor pro výchozí měrnou jednotku, musí být 1 v řádku {0}"
+apps/erpnext/erpnext/stock/doctype/item/item.py +408,Conversion factor for default Unit of Measure must be 1 in row {0},"Konverzní faktor pro výchozí měrnou jednotku, musí být 1 v řádku {0}"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +180,Leave of type {0} cannot be longer than {1},Leave typu {0} nemůže být delší než {1}
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,Skúste plánovanie operácií pre X dní vopred.
 DocType: HR Settings,Stop Birthday Reminders,Zastavit připomenutí narozenin
 DocType: SMS Center,Receiver List,Přijímač Seznam
-DocType: Payment Tool Detail,Payment Amount,Částka platby
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Spotřebovaném množství
-apps/erpnext/erpnext/public/js/pos/pos.js +520,{0} View,{0} Zobraziť
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +96,Net Change in Cash,Čistá zmena v hotovosti
 DocType: Salary Structure Deduction,Salary Structure Deduction,Plat Struktura Odpočet
-apps/erpnext/erpnext/stock/doctype/item/item.py +344,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Měrná jednotka {0} byl zadán více než jednou v konverzním faktorem tabulce
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,Payment Request already exists {0},Platba Dopyt už existuje {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +403,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Měrná jednotka {0} byl zadán více než jednou v konverzním faktorem tabulce
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +22,Payment Request already exists {0},Platba Dopyt už existuje {0}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Náklady na vydaných položek
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +185,Quantity must not be more than {0},Množství nesmí být větší než {0}
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +72,Previous Financial Year is not closed,Predchádzajúci finančný rok nie je uzavretý
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +41,Age (Days),Staroba (dni)
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +241,Quantity must not be more than {0},Množství nesmí být větší než {0}
+apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +76,Previous Financial Year is not closed,Predchádzajúci finančný rok nie je uzavretý
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +44,Age (Days),Staroba (dni)
 DocType: Quotation Item,Quotation Item,Položka ponuky
-DocType: Account,Account Name,Název účtu
+DocType: Account,Account Name,Názov účtu
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Dátum OD nemôže byť väčší ako dátum DO
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +194,Serial No {0} quantity {1} cannot be a fraction,Pořadové číslo {0} {1} množství nemůže být zlomek
 apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Dodavatel Type master.
 DocType: Purchase Order Item,Supplier Part Number,Dodavatel Číslo dílu
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +94,Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1
-DocType: Purchase Invoice,Reference Document,referenčný dokument
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +172,{0} {1} is cancelled or stopped,{0} {1} je zrušená alebo zastavená
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +98,Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1
+DocType: Sales Invoice,Reference Document,referenčný dokument
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +185,{0} {1} is cancelled or stopped,{0} {1} je zrušená alebo zastavená
 DocType: Accounts Settings,Credit Controller,Credit Controller
 DocType: Delivery Note,Vehicle Dispatch Date,Vozidlo Dispatch Datum
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +205,Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +221,Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena
 DocType: Company,Default Payable Account,Výchozí Splatnost účtu
-apps/erpnext/erpnext/config/website.py +12,"Settings for online shopping cart such as shipping rules, price list etc.","Nastavení pro on-line nákupního košíku, jako jsou pravidla dopravu, ceník atd"
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +80,{0}% Billed,{0}% fakturované
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +17,Reserved Qty,Reserved Množství
+apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Nastavení pro on-line nákupního košíku, jako jsou pravidla dopravu, ceník atd"
+apps/erpnext/erpnext/controllers/website_list_for_contact.py +83,{0}% Billed,{0}% fakturované
+apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Reserved Množství
 DocType: Party Account,Party Account,Party účtu
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +74,Human Resources,Lidské zdroje
+apps/erpnext/erpnext/config/setup.py +116,Human Resources,Lidské zdroje
 DocType: Lead,Upper Income,Horní příjmů
 DocType: Journal Entry Account,Debit in Company Currency,Debetnej v spoločnosti Mena
-apps/erpnext/erpnext/support/doctype/issue/issue.py +58,My Issues,Moje problémy
 DocType: BOM Item,BOM Item,BOM Item
 DocType: Appraisal,For Employee,Pro zaměstnance
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +111,Row {0}: Advance against Supplier must be debit,Riadok {0}: Advance proti dodávateľom musí byť odpísať
 DocType: Company,Default Values,Predvolené hodnoty
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +240,Row {0}: Payment amount can not be negative,Row {0}: Částka platby nemůže být záporný
 DocType: Expense Claim,Total Amount Reimbursed,Celkovej sumy vyplatenej
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +65,Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +80,Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
 DocType: Customer,Default Price List,Výchozí Ceník
 DocType: Payment Reconciliation,Payments,Platby
-DocType: Budget Detail,Budget Allocated,Přidělený Rozpočet
 DocType: Journal Entry,Entry Type,Entry Type
 ,Customer Credit Balance,Zákazník Credit Balance
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +21,Net Change in Accounts Payable,Čistá Zmena účty záväzkov
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +137,Please verify your email id,Overte prosím svoju e-mailovú id
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',"Zákazník požadoval pro 'Customerwise sleva """
-apps/erpnext/erpnext/config/accounts.py +137,Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
+apps/erpnext/erpnext/config/accounts.py +136,Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
 DocType: Quotation,Term Details,Termín Podrobnosti
 apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} musí byť väčšia ako 0
 DocType: Manufacturing Settings,Capacity Planning For (Days),Plánovanie kapacít Pro (dni)
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +63,None of the items have any change in quantity or value.,Žiadny z týchto položiek má žiadnu zmenu v množstve alebo hodnote.
-apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +30,Warranty Claim,Záruční reklamace
+apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +32,Warranty Claim,Záruční reklamace
 ,Lead Details,Podrobnosti Obchodnej iniciatívy
+DocType: Purchase Invoice,End date of current invoice's period,Datum ukončení doby aktuální faktury je
 DocType: Pricing Rule,Applicable For,Použitelné pro
 DocType: Bank Reconciliation,From Date,Od data
 DocType: Shipping Rule Country,Shipping Rule Country,Prepravné Pravidlo Krajina
 DocType: Maintenance Visit,Partially Completed,Částečně Dokončeno
 DocType: Leave Type,Include holidays within leaves as leaves,Zahrnúť dovolenku v listoch sú listy
 DocType: Sales Invoice,Packed Items,Zabalené položky
-apps/erpnext/erpnext/config/support.py +48,Warranty Claim against Serial No.,Reklamační proti sériového čísla
+apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Reklamační proti sériového čísla
 DocType: BOM Replace 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","Nahradit konkrétní kusovník ve všech ostatních kusovníky, kde se používá. To nahradí původní odkaz kusovníku, aktualizujte náklady a regenerovat ""BOM explozi položku"" tabulku podle nového BOM"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +56,'Total',&quot;Celkom&quot;
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.html +1,'Total',&quot;Celkom&quot;
 DocType: Shopping Cart Settings,Enable Shopping Cart,Povolit Nákupní košík
 DocType: Employee,Permanent Address,Trvalé bydliště
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +233,"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}
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +139,Please select item code,"Prosím, vyberte položku kód"
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +148,Please select item code,"Prosím, vyberte položku kód"
 DocType: Salary Structure Deduction,Reduce Deduction for Leave Without Pay (LWP),Snížit Odpočet o dovolenou bez nároku na odměnu (LWP)
 DocType: Territory,Territory Manager,Oblastní manažer
 DocType: Packed Item,To Warehouse (Optional),Warehouse (voliteľné)
-DocType: Sales Invoice,Paid Amount (Company Currency),Zaplatená suma (Company meny)
+DocType: Payment Entry,Paid Amount (Company Currency),Zaplatená suma (Company meny)
 DocType: Purchase Invoice,Additional Discount,Ďalšie zľavy
 DocType: Selling Settings,Selling Settings,Nastavenia pre Predaj
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +39,Online Auctions,Aukce online
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +101,Please specify either Quantity or Valuation Rate or both,"Uveďte prosím buď Množství nebo ocenění Cena, nebo obojí"
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +50,"Company, Month and Fiscal Year is mandatory","Společnost, měsíc a fiskální rok je povinný"
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +105,Marketing Expenses,Marketingové náklady
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +101,Marketing Expenses,Marketingové náklady
 ,Item Shortage Report,Položka Nedostatek Report
-apps/erpnext/erpnext/stock/doctype/item/item.js +181,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnost je uvedeno, \n uveďte prosím ""váha UOM"" příliš"
+apps/erpnext/erpnext/stock/doctype/item/item.js +224,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnosť je uvedená, \n uveďte prosím aj ""váhu MJ"""
 DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materiál Žádost používá k výrobě této populace Entry
-apps/erpnext/erpnext/config/support.py +53,Single unit of an Item.,Single jednotka položky.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +216,Time Log Batch {0} must be 'Submitted',"Time Log Batch {0} musí být ""Odesláno"""
+apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Single jednotka položky.
 DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Ujistěte se účetní položka pro každý pohyb zásob
 DocType: Leave Allocation,Total Leaves Allocated,Celkem Leaves Přidělené
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +385,Warehouse required at Row No {0},Warehouse vyžadované pri Row No {0}
-apps/erpnext/erpnext/public/js/setup_wizard.js +55,Please enter valid Financial Year Start and End Dates,Zadajte platnú finančný rok dátum začatia a ukončenia
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +154,Warehouse required at Row No {0},Warehouse vyžadované pri Row No {0}
+apps/erpnext/erpnext/public/js/setup_wizard.js +78,Please enter valid Financial Year Start and End Dates,Zadajte platnú finančný rok dátum začatia a ukončenia
 DocType: Employee,Date Of Retirement,Datum odchodu do důchodu
 DocType: Upload Attendance,Get Template,Získat šablonu
 DocType: Address,Postal,Poštovní
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +171,ERPNext Setup Complete!,Nastavenie ERPNext dokončené!
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +196,ERPNext Setup Complete!,Nastavenie ERPNext dokončené!
 DocType: Item,Weightage,Weightage
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +91,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Zákaznická Skupina existuje se stejným názvem, prosím změnit název zákazníka nebo přejmenujte skupinu zákazníků"
-apps/erpnext/erpnext/public/js/pos/pos.js +155,Please select {0} first.,"Prosím, vyberte {0} jako první."
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +93,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Zákaznická Skupina existuje se stejným názvem, prosím změnit název zákazníka nebo přejmenujte skupinu zákazníků"
 apps/erpnext/erpnext/public/js/templates/contact_list.html +2,New Contact,Nový kontakt
 DocType: Territory,Parent Territory,Parent Territory
 DocType: Quality Inspection Reading,Reading 2,Čtení 2
 DocType: Stock Entry,Material Receipt,Příjem materiálu
-apps/erpnext/erpnext/public/js/setup_wizard.js +268,Products,Výrobky
+DocType: Homepage,Products,Výrobky
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +48,Party Type and Party is required for Receivable / Payable account {0},Zadejte Party Party a je nutné pro pohledávky / závazky na účtu {0}
 DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ak je táto položka má varianty, potom to nemôže byť vybraná v predajných objednávok atď"
 DocType: Lead,Next Contact By,Další Kontakt By
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +225,Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +93,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} nelze smazat, protože existuje množství k položce {1}"
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +223,Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +110,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} nelze smazat, protože existuje množství k položce {1}"
 DocType: Quotation,Order Type,Typ objednávky
 DocType: Purchase Invoice,Notification Email Address,Oznámení e-mailová adresa
-DocType: Payment Tool,Find Invoices to Match,Nájsť faktúry zápas
 ,Item-wise Sales Register,Item-moudrý Sales Register
 DocType: Asset,Gross Purchase Amount,Gross Suma nákupu
-apps/erpnext/erpnext/public/js/setup_wizard.js +24,"e.g. ""XYZ National Bank""","napríklad ""XYZ Národná Banka"""
 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 +61,Total Target,Celkem Target
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.js +29,Shopping Cart is enabled,Nákupný košík je povolené
+apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Celkem Target
 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
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +235,No Production Orders created,Žádné výrobní zakázky vytvořené
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +151,Salary Slip of employee {0} already created for this month,Plat Slip of zaměstnance {0} již vytvořili pro tento měsíc
 DocType: Stock Reconciliation,Reconciliation JSON,Odsouhlasení JSON
-apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Příliš mnoho sloupců. Export zprávu a vytiskněte jej pomocí aplikace tabulky.
-DocType: Sales Invoice Item,Batch No,Č. šarže
+apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.html +1,Too many columns. Export the report and print it using a spreadsheet application.,Příliš mnoho sloupců. Export zprávu a vytiskněte jej pomocí aplikace tabulky.
+DocType: Purchase Invoice Item,Batch No,Č. šarže
 DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Povoliť viac Predajné objednávky proti Zákazníka Objednávky
-apps/erpnext/erpnext/setup/doctype/company/company.py +147,Main,Hlavné
-apps/erpnext/erpnext/stock/doctype/item/item.js +53,Variant,Varianta
+apps/erpnext/erpnext/setup/doctype/company/company.py +161,Main,Hlavné
+apps/erpnext/erpnext/stock/doctype/item/item.js +56,Variant,Varianta
 DocType: Naming Series,Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakcí
 DocType: Employee Attendance Tool,Employees HTML,Zamestnanci HTML
-apps/erpnext/erpnext/stock/doctype/item/item.py +366,Default BOM ({0}) must be active for this item or its template,Predvolené BOM ({0}) musí byť aktívna pre túto položku alebo jeho šablóny
+apps/erpnext/erpnext/stock/doctype/item/item.py +422,Default BOM ({0}) must be active for this item or its template,Predvolené BOM ({0}) musí byť aktívna pre túto položku alebo jeho šablóny
 DocType: Employee,Leave Encashed?,Ponechte zpeněžení?
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Opportunity Ze hřiště je povinné
 DocType: Item,Variants,Varianty
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +802,Make Purchase Order,Proveďte objednávky
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +815,Make Purchase Order,Proveďte objednávky
 DocType: SMS Center,Send To,Odeslat
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +131,There is not enough leave balance for Leave Type {0},Není dost bilance dovolenou na vstup typ {0}
 DocType: Payment Reconciliation Payment,Allocated amount,Přidělené sumy
@@ -1460,43 +1355,38 @@
 DocType: Sales Invoice Item,Customer's Item Code,Zákazníka Kód položky
 DocType: Stock Reconciliation,Stock Reconciliation,Reklamní Odsouhlasení
 DocType: Territory,Territory Name,Území Name
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +154,Work-in-Progress Warehouse is required before Submit,Work-in-Progress sklad je zapotřebí před Odeslat
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +168,Work-in-Progress Warehouse is required before Submit,Work-in-Progress sklad je zapotřebí před Odeslat
 apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Žadatel o zaměstnání.
 DocType: Purchase Order Item,Warehouse and Reference,Sklad a reference
 DocType: Supplier,Statutory info and other general information about your Supplier,Statutární info a další obecné informace o váš dodavatel
-apps/erpnext/erpnext/hooks.py +91,Addresses,Adresy
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +142,Against Journal Entry {0} does not have any unmatched {1} entry,Proti věstníku Vstup {0} nemá bezkonkurenční {1} vstupu
-apps/erpnext/erpnext/config/hr.py +141,Appraisals,ocenenie
+apps/erpnext/erpnext/hooks.py +88,Addresses,Adresy
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +212,Against Journal Entry {0} does not have any unmatched {1} entry,Proti věstníku Vstup {0} nemá bezkonkurenční {1} vstupu
+apps/erpnext/erpnext/config/hr.py +137,Appraisals,ocenenie
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,Duplicate Serial No entered for Item {0},Duplicitní Pořadové číslo vstoupil k bodu {0}
 DocType: Shipping Rule Condition,A condition for a Shipping Rule,Podmínka pro pravidla dopravy
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Item is not allowed to have Production Order.,Položka nesmie mať výrobné zákazky.
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +147,Please set filter based on Item or Warehouse,Prosím nastaviť filter na základe výtlačku alebo v sklade
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +149,Please set filter based on Item or Warehouse,Prosím nastaviť filter na základe výtlačku alebo v sklade
 DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnost tohoto balíčku. (Automaticky vypočítá jako součet čisté váhy položek)
 DocType: Sales Order,To Deliver and Bill,Dodať a Bill
 DocType: GL Entry,Credit Amount in Account Currency,Kreditné Čiastka v mene účtu
-apps/erpnext/erpnext/config/manufacturing.py +27,Time Logs for manufacturing.,Čas Protokoly pre výrobu.
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +439,BOM {0} must be submitted,BOM {0} musí být předloženy
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +442,BOM {0} must be submitted,BOM {0} musí být předloženy
 DocType: Authorization Control,Authorization Control,Autorizace Control
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +92,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Riadok # {0}: zamietnutie Warehouse je povinná proti zamietnutej bodu {1}
-apps/erpnext/erpnext/config/projects.py +35,Time Log for tasks.,Time Log pro úkoly.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +598,Payment,Splátka
+apps/erpnext/erpnext/controllers/buying_controller.py +300,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Riadok # {0}: zamietnutie Warehouse je povinná proti zamietnutej bodu {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +678,Payment,Splátka
 DocType: Production Order Operation,Actual Time and Cost,Skutečný Čas a Náklady
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +54,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materiál Žádost maximálně {0} lze k bodu {1} na odběratele {2}
 DocType: Employee,Salutation,Oslovení
 DocType: Pricing Rule,Brand,Značka
 DocType: Item,Will also apply for variants,Bude platiť aj pre varianty
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +91,"Asset cannot be cancelled, as it is already {0}","Asset nemožno zrušiť, pretože je už {0}"
-apps/erpnext/erpnext/config/stock.py +72,Bundle items at time of sale.,Bundle položky v okamžiku prodeje.
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +142,"Asset cannot be cancelled, as it is already {0}","Asset nemožno zrušiť, pretože je už {0}"
+apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Bundle položky v okamžiku prodeje.
 DocType: Quotation Item,Actual Qty,Skutečné Množství
 DocType: Sales Invoice Item,References,Referencie
 DocType: Quality Inspection Reading,Reading 10,Čtení 10
-apps/erpnext/erpnext/public/js/setup_wizard.js +258,"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Vypíšte zopár produktov alebo služieb, ktoré predávate alebo kupujete. Po spustení systému sa presvečte, či majú tieto položky správne nastavenú mernú jednotku, kategóriu a ostatné vlastnosti."
+apps/erpnext/erpnext/public/js/setup_wizard.js +284,"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Vypíšte zopár produktov alebo služieb, ktoré predávate alebo kupujete. Po spustení systému sa presvečte, či majú tieto položky správne nastavenú mernú jednotku, kategóriu a ostatné vlastnosti."
 DocType: Hub Settings,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/controllers/item_variant.py +66,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values,Hodnota {0} pre atribút {1} neexistuje v zozname platného bodu Hodnoty atribútov
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +87,Associate,Spolupracovník
 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: Request for Quotation Supplier,Send Email to Supplier,Odoslať e-mail na dodávateľa
 DocType: SMS Center,Create Receiver List,Vytvořit přijímače seznam
 DocType: Packing Slip,To Package No.,Balit No.
 DocType: Production Planning Tool,Material Requests,materiál Žiadosti
@@ -1505,16 +1395,16 @@
 DocType: Purchase Receipt Item Supplied,Consumed Qty,Spotřeba Množství
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +52,Telecommunications,Telekomunikace
 DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Označuje, že balíček je součástí této dodávky (Pouze návrhu)"
-DocType: Payment Tool,Make Payment Entry,Učinit vstup platby
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Učinit vstup platby
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +126,Quantity for Item {0} must be less than {1},Množství k bodu {0} musí být menší než {1}
 ,Sales Invoice Trends,Prodejní faktury Trendy
 DocType: Leave Application,Apply / Approve Leaves,Použít / Schválit listy
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +23,For,Pre
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +90,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Se může vztahovat řádku, pouze pokud typ poplatku je ""On předchozí řady Částka"" nebo ""předchozí řady Total"""
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +106,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Se může vztahovat řádku, pouze pokud typ poplatku je ""On předchozí řady Částka"" nebo ""předchozí řady Total"""
 DocType: Sales Order Item,Delivery Warehouse,Dodávka Warehouse
 DocType: Stock Settings,Allowance Percent,Allowance Procento
 DocType: SMS Settings,Message Parameter,Parametr zpráv
-apps/erpnext/erpnext/config/accounts.py +200,Tree of financial Cost Centers.,Strom Nákl.stredisko finančných.
+apps/erpnext/erpnext/config/accounts.py +199,Tree of financial Cost Centers.,Strom Nákl.stredisko finančných.
 DocType: Serial No,Delivery Document No,Dodávka dokument č
 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í
@@ -1524,87 +1414,80 @@
 DocType: Purchase Order Item,Supplier Quotation Item,Položka dodávateľskej ponuky
 DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Zakáže vytváranie časových protokolov proti výrobnej zákazky. Transakcie nesmú byť sledované proti výrobnej zákazky
 DocType: Item,Has Variants,Má varianty
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +22,Click on 'Make Sales Invoice' button to create a new Sales Invoice.,"Klikněte na tlačítko "", aby se prodej na faktuře"" vytvořit nový prodejní faktury."
 DocType: Monthly Distribution,Name of the Monthly Distribution,Název měsíční výplatou
 DocType: Sales Person,Parent Sales Person,Parent obchodník
 apps/erpnext/erpnext/setup/utils.py +14,Please specify Default Currency in Company Master and Global Defaults,"Uveďte prosím výchozí měnu, ve společnosti Master and Global výchozí"
 DocType: Purchase Invoice,Recurring Invoice,Opakující se faktury
-apps/erpnext/erpnext/config/projects.py +78,Managing Projects,Správa projektov
+apps/erpnext/erpnext/config/learn.py +268,Managing Projects,Správa projektov
 DocType: Supplier,Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
-DocType: Budget Detail,Fiscal Year,Fiskální rok
-DocType: Cost Center,Budget,Rozpočet
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +41,"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"
+DocType: Budget,Fiscal Year,Fiskální rok
+DocType: Budget,Budget,Rozpočet
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +44,"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/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Dosažená
 apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +65,Territory / Customer,Territory / Customer
-apps/erpnext/erpnext/public/js/setup_wizard.js +201,e.g. 5,napríklad 5
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +150,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: Přidělená částka {1} musí být menší než nebo se rovná fakturovat dlužné částky {2}
+apps/erpnext/erpnext/public/js/setup_wizard.js +227,e.g. 5,napríklad 5
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +166,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: Přidělená částka {1} musí být menší než nebo se rovná fakturovat dlužné částky {2}
 DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,"Ve slovech budou viditelné, jakmile uložíte prodejní faktury."
-DocType: Item,Is Sales Item,Je Sales Item
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Položka Group Tree
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,"Položka {0} není nastavení pro Serial č. Zkontrolujte, zda master položku"
 DocType: Maintenance Visit,Maintenance Time,Údržba Time
 ,Amount to Deliver,"Suma, ktorá má dodávať"
-apps/erpnext/erpnext/public/js/setup_wizard.js +266,A Product or Service,Produkt alebo Služba
+apps/erpnext/erpnext/public/js/setup_wizard.js +292,A Product or Service,Produkt alebo Služba
 DocType: Naming Series,Current Value,Current Value
-apps/erpnext/erpnext/controllers/accounts_controller.py +226,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Niekoľko fiškálnych rokov existujú pre dáta {0}. Prosím nastavte spoločnosť vo fiškálnom roku
+apps/erpnext/erpnext/controllers/accounts_controller.py +235,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Niekoľko fiškálnych rokov existujú pre dáta {0}. Prosím nastavte spoločnosť vo fiškálnom roku
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +233,{0} created,{0} vytvoril
 DocType: Delivery Note Item,Against Sales Order,Proti přijaté objednávce
 ,Serial No Status,Serial No Status
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +448,Item table can not be blank,Tabulka Položka nemůže být prázdný
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +129,"Row {0}: To set {1} periodicity, difference between from and to date \
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +458,Item table can not be blank,Tabulka Položka nemůže být prázdný
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +138,"Row {0}: To set {1} periodicity, difference between from and to date \
 						must be greater than or equal to {2}","Řádek {0}: Pro nastavení {1} periodicita, rozdíl mezi z a aktuální \
  musí být větší než nebo rovno {2}"
 DocType: Pricing Rule,Selling,Predaj
 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 +277,Due Date cannot be before Posting Date,Datum splatnosti nesmí být před odesláním Datum
+apps/erpnext/erpnext/accounts/party.py +296,Due Date cannot be before Posting Date,Datum splatnosti nesmí být před odesláním Datum
 DocType: Website Item Group,Website Item Group,Website Item Group
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +173,Duties and Taxes,Odvody a dane
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +147,Duties and Taxes,Odvody a dane
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +326,Please enter Reference date,"Prosím, zadejte Referenční den"
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +33,Payment Gateway Account is not configured,Platobná brána účet nie je nakonfigurovaný
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} platobné položky nemôžu byť filtrované podľa {1}
 DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabulka k bodu, který se zobrazí na webových stránkách"
 DocType: Purchase Order Item Supplied,Supplied Qty,Dodávané Množstvo
-DocType: Request for Quotation Item,Material Request Item,Materiál Žádost o bod
-apps/erpnext/erpnext/config/stock.py +85,Tree of Item Groups.,Strom skupiny položek.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +100,Cannot refer row number greater than or equal to current row number for this Charge type,Nelze odkazovat číslo řádku větší nebo rovnou aktuální číslo řádku pro tento typ Charge
+DocType: Purchase Order Item,Material Request Item,Materiál Žádost o bod
+apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Strom skupiny položek.
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +116,Cannot refer row number greater than or equal to current row number for this Charge type,Nelze odkazovat číslo řádku větší nebo rovnou aktuální číslo řádku pro tento typ Charge
 DocType: Asset,Sold,Predané
 ,Item-wise Purchase History,Item-moudrý Historie nákupů
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +152,Red,Červená
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosím, klikněte na ""Generovat Schedule"", aby přinesla Pořadové číslo přidán k bodu {0}"
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +161,Red,Červená
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +228,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosím, klikněte na ""Generovat Schedule"", aby přinesla Pořadové číslo přidán k bodu {0}"
 DocType: Account,Frozen,Zmražený
 ,Open Production Orders,Otevřené výrobní zakázky
 DocType: Installation Note,Installation Time,Instalace Time
 DocType: Sales Invoice,Accounting Details,Účtovné Podrobnosti
 apps/erpnext/erpnext/setup/doctype/company/company.js +66,Delete all the Transactions for this Company,Odstráňte všetky transakcie pre túto spoločnosť
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} není dokončen {2} Množství hotových výrobků ve výrobním procesu objednávky # {3}. Prosím aktualizujte provozní stav přes čas protokoly
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +60,Investments,Investice
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +187,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} není dokončen {2} Množství hotových výrobků ve výrobním procesu objednávky # {3}. Prosím aktualizujte provozní stav přes čas protokoly
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +66,Investments,Investice
 DocType: Issue,Resolution Details,Rozlišení Podrobnosti
 apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,alokácie
 DocType: Quality Inspection Reading,Acceptance Criteria,Kritéria přijetí
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +163,Please enter Material Requests in the above table,"Prosím, zadajte Žiadosti materiál vo vyššie uvedenej tabuľke"
-DocType: Item Attribute,Attribute Name,Název atributu
+DocType: Item Attribute,Attribute Name,Názov atribútu
 DocType: Item Group,Show In Website,Show pro webové stránky
-apps/erpnext/erpnext/public/js/setup_wizard.js +267,Group,Skupina
+apps/erpnext/erpnext/public/js/setup_wizard.js +293,Group,Skupina
 DocType: Task,Expected Time (in hours),Predpokladaná doba (v hodinách)
 ,Qty to Order,Množství k objednávce
-DocType: Features Setup,"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Product Bundle, Sales Order, Serial No","Ak chcete sledovať značku v nasledujúcich dokumentoch dodacom liste Opportunity, materiál Request, položka, objednávke, kúpnej poukazu, nakupujú potvrdenka, cenovú ponuku, predajné faktúry, Product Bundle, predajné objednávky, poradové číslo"
 apps/erpnext/erpnext/config/projects.py +25,Gantt chart of all tasks.,Ganttův diagram všech zadaných úkolů.
 DocType: Pricing Rule,Margin Type,margin Type
 DocType: Appraisal,For Employee Name,Pro jméno zaměstnance
 DocType: Holiday List,Clear Table,Clear Table
-DocType: Features Setup,Brands,Značky
 DocType: C-Form Invoice Detail,Invoice No,Faktúra č.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +95,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Nechajte nemožno aplikovať / zrušená pred {0}, pretože rovnováha dovolenky už bolo carry-odovzdávané v budúcej pridelenie dovolenku záznamu {1}"
 DocType: Activity Cost,Costing Rate,Kalkulácie Rate
 ,Customer Addresses And Contacts,Adresy zákazníkov a kontakty
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +259,Row #{0}: Asset is mandatory against a Fixed Asset Item,Riadok # {0}: Prostriedok je povinná proti dlhodobého majetku výtlačku
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +87,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Prosím nastaviť číslovanie série pre dochádzky prostredníctvom ponuky Setup&gt; Číslovanie Series
 DocType: Employee,Resignation Letter Date,Rezignace Letter Datum
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +37,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/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Repeat Customer Příjmy
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +49,{0} ({1}) must have role 'Expense Approver',"{0} ({1}), musí mať úlohu ""Schvalovateľ výdajov"""
-apps/erpnext/erpnext/public/js/setup_wizard.js +272,Pair,Pár
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +50,{0} ({1}) must have role 'Expense Approver',"{0} ({1}), musí mať úlohu ""Schvalovateľ výdajov"""
+apps/erpnext/erpnext/public/js/setup_wizard.js +298,Pair,Pár
 DocType: Asset,Depreciation Schedule,plán odpisy
 DocType: Bank Reconciliation Detail,Against Account,Proti účet
 DocType: Maintenance Schedule Detail,Actual Date,Skutečné datum
@@ -1612,17 +1495,18 @@
 DocType: Delivery Note,Excise Page Number,Spotřební Číslo stránky
 DocType: Asset,Purchase Date,Dátum nákupu
 DocType: Employee,Personal Details,Osobní data
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +170,Please set 'Asset Depreciation Cost Center' in Company {0},Prosím nastavte &quot;odpisy majetku nákladové stredisko&quot; vo firme {0}
+apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +182,Please set 'Asset Depreciation Cost Center' in Company {0},Prosím nastavte &quot;odpisy majetku nákladové stredisko&quot; vo firme {0}
 ,Maintenance Schedules,Plány údržby
 ,Quotation Trends,Vývoje ponúk
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +138,Item Group not mentioned in item master for item {0},Položka Group není uvedeno v položce mistra na položku {0}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +309,Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +296,Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
 DocType: Shipping Rule Condition,Shipping Amount,Přepravní Částka
 ,Pending Amount,Čeká Částka
 DocType: Purchase Invoice Item,Conversion Factor,Konverzní faktor
 DocType: Purchase Order,Delivered,Dodává
 DocType: Purchase Receipt,Vehicle Number,Číslo vozidla
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,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: Purchase Invoice,The date on which recurring invoice will be stop,"Datum, kdy opakující se faktura bude zastaví"
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +90,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: Journal Entry,Accounts Receivable,Pohledávky
 ,Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics
 DocType: Address Template,This format is used if country specific format is not found,"Tento formát se používá, když specifický formát země není nalezen"
@@ -1631,120 +1515,112 @@
 DocType: Leave Control Panel,Leave blank if considered for all employee types,"Ponechte prázdné, pokud se to považuje za ubytování ve všech typech zaměstnanců"
 DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuovat poplatků na základě
 DocType: HR Settings,HR Settings,Nastavení HR
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +127,Expense Claim is pending approval. Only the Expense Approver can update status.,Úhrada výdajů čeká na schválení. Pouze schalovatel výdajů může aktualizovat stav.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +117,Expense Claim is pending approval. Only the Expense Approver can update status.,Úhrada výdajů čeká na schválení. Pouze schalovatel výdajů může aktualizovat stav.
 DocType: Purchase Invoice,Additional Discount Amount,Dodatočná zľava Suma
 DocType: Leave Block List Allow,Leave Block List Allow,Nechte Block List Povolit
-apps/erpnext/erpnext/setup/doctype/company/company.py +237,Abbr can not be blank or space,Skrátená nemôže byť prázdne alebo priestor
-apps/erpnext/erpnext/accounts/doctype/account/account.js +54,Group to Non-Group,Skupina na Non-Group
+apps/erpnext/erpnext/setup/doctype/company/company.py +246,Abbr can not be blank or space,Skrátená nemôže byť prázdne alebo priestor
+apps/erpnext/erpnext/accounts/doctype/account/account.js +53,Group to Non-Group,Skupina na Non-Group
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,Sportovní
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +61,Total Actual,Celkem Aktuální
-apps/erpnext/erpnext/public/js/setup_wizard.js +272,Unit,Jednotka
+apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Celkem Aktuální
+apps/erpnext/erpnext/public/js/setup_wizard.js +298,Unit,Jednotka
 apps/erpnext/erpnext/stock/get_item_details.py +123,Please specify Company,"Uveďte prosím, firmu"
 ,Customer Acquisition and Loyalty,Zákazník Akvizice a loajality
-DocType: Purchase Receipt,Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek"
-apps/erpnext/erpnext/public/js/setup_wizard.js +42,Your financial year ends on,Váš finančný rok končí
+DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek"
+apps/erpnext/erpnext/public/js/setup_wizard.js +63,Your financial year ends on,"Dátum, kedy váš finančný rok končí"
 DocType: POS Profile,Price List,Ceník
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +20,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,"{0} je teraz predvolený Fiškálny rok. Prosím aktualizujte svoj prehliadač, aby se prejavili zmeny."
-apps/erpnext/erpnext/projects/doctype/project/project.js +58,Expense Claims,Nákladové Pohľadávky
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,"{0} je teraz predvolený Fiškálny rok. Prosím aktualizujte svoj prehliadač, aby sa prejavili zmeny."
+apps/erpnext/erpnext/projects/doctype/task/task.js +26,Expense Claims,Nákladové Pohľadávky
 DocType: Issue,Support,Podpora
 ,BOM Search,BOM Search
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +176,Closing (Opening + Totals),Uzavretie (Otvorenie + súčty)
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +180,Closing (Opening + Totals),Uzavretie (Otvorenie + súčty)
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +26,Please specify currency in Company,"Uveďte prosím měnu, ve společnosti"
 DocType: Workstation,Wages per hour,Mzda za hodinu
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +49,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Sklad bilance v dávce {0} se zhorší {1} k bodu {2} ve skladu {3}
-apps/erpnext/erpnext/config/setup.py +83,"Show / Hide features like Serial Nos, POS etc.","Zobrazit / skrýt funkce, jako pořadová čísla, POS atd"
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +50,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Sklad bilance v dávce {0} se zhorší {1} k bodu {2} ve skladu {3}
 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
-apps/erpnext/erpnext/controllers/accounts_controller.py +262,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatná. Mena účtu musí byť {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +272,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatná. Mena účtu musí byť {1}
 apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.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/bank_reconciliation/bank_reconciliation.py +56,Clearance date cannot be before check date in row {0},Datum vůle nemůže být před přihlášením dnem v řadě {0}
 DocType: Salary Slip,Deduction,Dedukce
-apps/erpnext/erpnext/stock/get_item_details.py +261,Item Price added for {0} in Price List {1},Položka Cena pridaný pre {0} v Cenníku {1}
+apps/erpnext/erpnext/stock/get_item_details.py +262,Item Price added for {0} in Price List {1},Položka Cena pridaný pre {0} v Cenníku {1}
 DocType: Address Template,Address Template,Šablona adresy
-apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +128,Please enter Employee Id of this sales person,"Prosím, zadajte ID zamestnanca z tohto predaja osoby"
+apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +7,Please enter Employee Id of this sales person,"Prosím, zadajte ID zamestnanca z tohto predaja osoby"
 DocType: Territory,Classification of Customers by region,Rozdělení zákazníků podle krajů
 DocType: Project,% Tasks Completed,% splnených úloh
 DocType: Project,Gross Margin,Hrubá marža
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +138,Please enter Production Item first,"Prosím, zadejte první výrobní položku"
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +53,Calculated Bank Statement balance,Vypočítaná výpis z bankového účtu zostatok
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +194,Please enter Production Item first,"Prosím, zadejte první výrobní položku"
+apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Vypočítaná výpis z bankového účtu zostatok
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,zakázané uživatelské
 apps/erpnext/erpnext/crm/doctype/lead/lead.js +32,Quotation,Ponuka
 DocType: Salary Slip,Total Deduction,Celkem Odpočet
-DocType: Quotation,Maintenance User,Údržba uživatele
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +151,Cost Updated,Náklady Aktualizované
+DocType: Maintenance Visit,Maintenance User,Údržba uživatele
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +149,Cost Updated,Náklady Aktualizované
 DocType: Employee,Date of Birth,Datum narození
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +85,Item {0} has already been returned,Bod {0} již byla vrácena
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +86,Item {0} has already been returned,Bod {0} již byla vrácena
 DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiškálny rok ** predstavuje finančný rok. Všetky účtovné záznamy a ďalšie významné transakcie sú sledované pod ** Fiškálny rok **.
 DocType: Opportunity,Customer / Lead Address,Zákazník / Iniciatíva Adresa
-apps/erpnext/erpnext/stock/doctype/item/item.py +156,Warning: Invalid SSL certificate on attachment {0},Varovanie: Neplatný certifikát SSL na prílohu {0}
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +28,Please setup Employee Naming System in Human Resource &gt; HR Settings,Prosím setup zamestnancov vymenovať systém v oblasti ľudských zdrojov&gt; Nastavenie HR
+apps/erpnext/erpnext/stock/doctype/item/item.py +205,Warning: Invalid SSL certificate on attachment {0},Varovanie: Neplatný certifikát SSL na prílohu {0}
 DocType: Production 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/install_fixtures.py +170,Job Description,Popis Práca
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +179,Job Description,Popis Práca
 DocType: Purchase Order Item,Qty as per Stock UOM,Množstvo podľa skladovej MJ
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +126,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Špeciálne znaky okrem ""-"". """", ""#"", a ""/"" nie sú povolené v číselnej rade"
 DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Mějte přehled o prodejních kampaní. Mějte přehled o Leads, citace, prodejní objednávky atd z kampaně, aby zjistily, návratnost investic."
 DocType: Expense Claim,Approver,Schvalovatel
 ,SO Qty,SO Množství
-apps/erpnext/erpnext/accounts/doctype/account/account.py +179,"Stock entries exist against warehouse {0}, hence you cannot re-assign or modify Warehouse","Přírůstky zásob existují proti skladu {0}, a proto není možné přeřadit nebo upravit Warehouse"
-DocType: Appraisal,Calculate Total Score,Vypočítat Celková skóre
-DocType: Request for Quotation,Manufacturing Manager,Výrobní ředitel
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +182,Serial No {0} is under warranty upto {1},Pořadové číslo {0} je v záruce aľ {1}
-apps/erpnext/erpnext/config/stock.py +154,Split Delivery Note into packages.,Rozdělit dodací list do balíčků.
-apps/erpnext/erpnext/hooks.py +71,Shipments,Zásielky
+DocType: Appraisal,Calculate Total Score,Vypočítať celkové skóre
+DocType: Request for Quotation,Manufacturing Manager,Výrobný riaditeľ
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Pořadové číslo {0} je v záruce aľ {1}
+apps/erpnext/erpnext/config/stock.py +153,Split Delivery Note into packages.,Rozdělit dodací list do balíčků.
+apps/erpnext/erpnext/hooks.py +74,Shipments,Zásielky
 DocType: Purchase Order Item,To be delivered to customer,Ak chcete byť doručený zákazníkovi
-apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +44,Time Log Status must be Submitted.,Time Log Status musí být předloženy.
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +223,Serial No {0} does not belong to any Warehouse,"Poradové číslo {0} nepatrí do skladu,"
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +157,Row # ,Row #
 DocType: Purchase Invoice,In Words (Company Currency),Slovy (měna společnosti)
 DocType: Asset,Supplier,Dodávateľ
+apps/erpnext/erpnext/public/js/utils.js +156,Get From,Získat Z
 DocType: C-Form,Quarter,Čtvrtletí
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +108,Miscellaneous Expenses,Různé výdaje
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +104,Miscellaneous Expenses,Různé výdaje
 DocType: Global Defaults,Default Company,Výchozí Company
-apps/erpnext/erpnext/controllers/stock_controller.py +167,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Náklady nebo Rozdíl účet je povinné k bodu {0} jako budou mít dopad na celkovou hodnotu zásob
-apps/erpnext/erpnext/controllers/accounts_controller.py +363,"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","Nelze overbill k bodu {0} v řadě {1} více než {2}. Chcete-li povolit nadfakturace, prosím nastavte na skladě Nastavení"
-DocType: Employee,Bank Name,Název banky
+apps/erpnext/erpnext/controllers/stock_controller.py +166,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Náklady nebo Rozdíl účet je povinné k bodu {0} jako budou mít dopad na celkovou hodnotu zásob
+apps/erpnext/erpnext/controllers/accounts_controller.py +416,"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","Nelze overbill k bodu {0} v řadě {1} více než {2}. Chcete-li povolit nadfakturace, prosím nastavte na skladě Nastavení"
+DocType: Cheque Print Template,Bank Name,Název banky
 apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +27,-Above,-Nad
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +139,User {0} is disabled,Uživatel {0} je zakázána
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +136,User {0} is disabled,Uživatel {0} je zakázána
 DocType: Leave Application,Total Leave Days,Celkový počet dnů dovolené
 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/accounts/page/financial_analytics/financial_analytics.js +36,Select Company...,Vyberte společnost ...
+apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +98,Select Company...,Vyberte společnost ...
 DocType: Leave Control Panel,Leave blank if considered for all departments,"Ponechte prázdné, pokud se to považuje za všechna oddělení"
-apps/erpnext/erpnext/config/hr.py +175,"Types of employment (permanent, contract, intern etc.).","Druhy pracovního poměru (trvalý, smluv, stážista atd.)"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +354,{0} is mandatory for Item {1},{0} je povinná k položke {1}
+apps/erpnext/erpnext/config/hr.py +171,"Types of employment (permanent, contract, intern etc.).","Druhy pracovního poměru (trvalý, smluv, stážista atd.)"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +341,{0} is mandatory for Item {1},{0} je povinná k položke {1}
 DocType: Currency Exchange,From Currency,Od Měny
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +154,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosím, vyberte alokovaná částka, typ faktury a číslo faktury v aspoň jedné řadě"
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosím, vyberte alokovaná částka, typ faktury a číslo faktury v aspoň jedné řadě"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +94,Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0}
 DocType: Purchase Invoice Item,Rate (Company Currency),Cena (Měna Společnosti)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +40,Others,Ostatní
+apps/erpnext/erpnext/demo/setup_data.py +347,Others,Ostatní
 apps/erpnext/erpnext/templates/includes/product_page.js +65,Cannot find a matching Item. Please select some other value for {0}.,Nemožno nájsť zodpovedajúce položku. Vyberte nejakú inú hodnotu pre {0}.
 DocType: POS Profile,Taxes and Charges,Daně a poplatky
 DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která se Nakupuje, Prodává nebo Skladuje."
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +94,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
-apps/erpnext/erpnext/controllers/accounts_controller.py +478,"Row #{0}: Qty must be 1, as item is linked to an asset","Riadok # {0}: Množstvo musí byť jedno, pretože položka je spojená s aktívom"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +110,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
 apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Dieťa Položka by nemala byť produkt Bundle. Odstráňte položku `{0}` a uložiť
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Bankovnictví
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,"Prosím, klikněte na ""Generovat Schedule"", aby se plán"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +299,New Cost Center,Nové Nákladové Stredisko
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,"Prosím, klikněte na ""Generovat Schedule"", aby se plán"
 DocType: Bin,Ordered Quantity,Objednané množství
-apps/erpnext/erpnext/public/js/setup_wizard.js +22,"e.g. ""Build tools for builders""","napríklad ""Nástroje pre stavbárov """
+apps/erpnext/erpnext/public/js/setup_wizard.js +52,"e.g. ""Build tools for builders""","napríklad ""Nástroje pre stavbárov """
 DocType: Quality Inspection,In Process,V procesu
 DocType: Authorization Rule,Itemwise Discount,Itemwise Sleva
-apps/erpnext/erpnext/config/accounts.py +58,Tree of financial accounts.,Strom finančných účtov.
-DocType: Purchase Order Item,Reference Document Type,Referenčná Typ dokumentu
+apps/erpnext/erpnext/config/accounts.py +63,Tree of financial accounts.,Strom finančných účtov.
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +334,{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 +305,Serialized Inventory,Serialized Zásoby
+apps/erpnext/erpnext/config/stock.py +304,Serialized Inventory,Serialized Zásoby
 DocType: Activity Type,Default Billing Rate,Predvolené fakturácia Rate
-DocType: Time Log Batch,Total Billing Amount,Celková suma fakturácie
-apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +47,Receivable Account,Pohledávky účtu
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +273,Row #{0}: Asset {1} is already {2},Riadok # {0}: Asset {1} je už {2}
+DocType: Sales Invoice,Total Billing Amount,Celková suma fakturácie
+apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +54,Receivable Account,Pohledávky účtu
+apps/erpnext/erpnext/controllers/accounts_controller.py +546,Row #{0}: Asset {1} is already {2},Riadok # {0}: Asset {1} je už {2}
 DocType: Quotation Item,Stock Balance,Reklamní Balance
-apps/erpnext/erpnext/config/selling.py +306,Sales Order to Payment,Predajné objednávky na platby
+apps/erpnext/erpnext/config/selling.py +302,Sales Order to Payment,Predajné objednávky na platby
 DocType: Expense Claim Detail,Expense Claim Detail,Detail úhrady výdajů
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +283,Time Logs created:,Čas Záznamy vytvořil:
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +796,Please select correct account,"Prosím, vyberte správny účet"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +805,Please select correct account,"Prosím, vyberte správny účet"
 DocType: Item,Weight UOM,Hmotnostná MJ
 DocType: Employee,Blood Group,Krevní Skupina
 DocType: Purchase Invoice Item,Page Break,Zalomení stránky
@@ -1761,63 +1637,59 @@
 DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ak ste vytvorili štandardné šablónu v predaji daní a poplatkov šablóny, vyberte jednu a kliknite na tlačidlo nižšie."
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +29,Please specify a country for this Shipping Rule or check Worldwide Shipping,"Uveďte prosím krajinu, k tomuto Shipping pravidlá alebo skontrolovať Celosvetová doprava"
 DocType: Stock Entry,Total Incoming Value,Celková hodnota Příchozí
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +303,Debit To is required,Debetné K je vyžadované
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +290,Debit To is required,Debetné K je vyžadované
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Nákupní Ceník
 DocType: Offer Letter Term,Offer Term,Ponuka Term
-DocType: Quality Inspection,Quality Manager,Manažer kvality
+DocType: Quality Inspection,Quality Manager,Manažér kvality
 DocType: Job Applicant,Job Opening,Job Zahájení
 DocType: Payment Reconciliation,Payment Reconciliation,Platba Odsouhlasení
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +145,Please select Incharge Person's name,"Prosím, vyberte incharge jméno osoby"
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +154,Please select Incharge Person's name,"Prosím, vyberte incharge jméno osoby"
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +51,Technology,Technologie
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Ponuka Letter
 apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Generování materiálu Požadavky (MRP) a výrobní zakázky.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +62,Total Invoiced Amt,Celkové fakturované Amt
-DocType: Time Log,To Time,Chcete-li čas
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.html +1,Total Invoiced Amt,Celkové fakturované Amt
+DocType: Timesheet Detail,To Time,Chcete-li čas
 DocType: Authorization Rule,Approving Role (above authorized value),Schválenie role (nad oprávnenej hodnoty)
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +25,"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Chcete-li přidat podřízené uzly, prozkoumat stromu a klepněte na položku, pod kterou chcete přidat více uzlů."
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +104,Credit To account must be a Payable account,Připsat na účet musí být Splatnost účet
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +243,BOM recursion: {0} cannot be parent or child of {2},BOM rekurze: {0} nemůže být rodič nebo dítě {2}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Credit To account must be a Payable account,Připsat na účet musí být Splatnost účet
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +241,BOM recursion: {0} cannot be parent or child of {2},BOM rekurze: {0} nemůže být rodič nebo dítě {2}
 DocType: Production Order Operation,Completed Qty,Dokončené Množství
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +121,"For {0}, only debit accounts can be linked against another credit entry","Pro {0}, tak debetní účty mohou být spojeny proti jinému připsání"
-apps/erpnext/erpnext/stock/get_item_details.py +272,Price List {0} is disabled,Ceník {0} je zakázána
+apps/erpnext/erpnext/stock/get_item_details.py +273,Price List {0} is disabled,Ceník {0} je zakázána
 DocType: Manufacturing Settings,Allow Overtime,Povoliť Nadčasy
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +197,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Sériové čísla požadované pre položku {1}. Poskytli ste {2}.
 DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuálne ocenenie Rate
 DocType: Item,Customer Item Codes,Zákazník Položka Kódy
 DocType: Opportunity,Lost Reason,Ztracené Důvod
-apps/erpnext/erpnext/config/accounts.py +131,Create Payment Entries against Orders or Invoices.,Vytvořte Platební záznamy proti objednávky nebo faktury.
 apps/erpnext/erpnext/public/js/templates/address_list.html +1,New Address,Nová adresa
 DocType: Quality Inspection,Sample Size,Velikost vzorku
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +488,All items have already been invoiced,Všechny položky již byly fakturovány
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +378,All items have already been invoiced,Všechny položky již byly fakturovány
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +47,Please specify a valid 'From Case No.',"Uveďte prosím platný ""Od věci č '"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +303,Further cost centers can be made under Groups but entries can be made against non-Groups,"Ďalšie nákladové strediská môžu byť vyrobené v rámci skupiny, ale položky môžu byť vykonané proti non-skupín"
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,"Ďalšie nákladové strediská môžu byť vyrobené v rámci skupiny, ale položky môžu byť vykonané proti non-skupín"
 DocType: Project,External,Externí
-DocType: Features Setup,Item Serial Nos,Položka sériových čísel
 apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Uživatelé a oprávnění
 DocType: Branch,Branch,Větev
 apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Tisk a identita
 apps/erpnext/erpnext/hr/report/monthly_salary_register/monthly_salary_register.py +66,No salary slip found for month:,No plat skluzu nalezen na měsíc:
 DocType: Bin,Actual Quantity,Skutečné Množství
 DocType: Shipping Rule,example: Next Day Shipping,Příklad: Next Day Shipping
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +179,Serial No {0} not found,Pořadové číslo {0} nebyl nalezen
-apps/erpnext/erpnext/public/js/setup_wizard.js +211,Your Customers,Vaši Zákazníci
-apps/erpnext/erpnext/projects/doctype/project/project.py +131,You have been invited to collaborate on the project: {0},Boli ste pozvaní k spolupráci na projekte: {0}
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +188,Serial No {0} not found,Pořadové číslo {0} nebyl nalezen
+apps/erpnext/erpnext/public/js/setup_wizard.js +237,Your Customers,Vaši Zákazníci
+apps/erpnext/erpnext/projects/doctype/project/project.py +139,You have been invited to collaborate on the project: {0},Boli ste pozvaní k spolupráci na projekte: {0}
 DocType: Leave Block List Date,Block Date,Block Datum
-apps/erpnext/erpnext/templates/generators/job_opening.html +18,Apply Now,Nainštalovať teraz
+apps/erpnext/erpnext/templates/generators/job_opening.html +19,Apply Now,Nainštalovať teraz
 DocType: Sales Order,Not Delivered,Nedodané
 ,Bank Clearance Summary,Souhrn bankovního zúčtování
-apps/erpnext/erpnext/config/setup.py +105,"Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest."
+apps/erpnext/erpnext/config/setup.py +100,"Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest."
 DocType: Appraisal Goal,Appraisal Goal,Posouzení Goal
-DocType: Time Log,Costing Amount,Kalkulácie Čiastka
+DocType: Timesheet Detail,Costing Amount,Kalkulácie Čiastka
 DocType: Process Payroll,Submit Salary Slip,Odeslat výplatní pásce
-DocType: Salary Structure,Monthly Earning & Deduction,Měsíčního výdělku a dedukce
-apps/erpnext/erpnext/controllers/selling_controller.py +157,Maxiumm discount for Item {0} is {1}%,Maxiumm sleva na položky {0} {1}%
+apps/erpnext/erpnext/controllers/selling_controller.py +161,Maxiumm discount for Item {0} is {1}%,Maxiumm sleva na položky {0} {1}%
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Dovoz hromadnú
 DocType: Sales Partner,Address & Contacts,Adresa a kontakty
 DocType: SMS Log,Sender Name,Meno odosielateľa
 DocType: POS Profile,[Select],[Vybrať]
 DocType: SMS Log,Sent To,Odoslaná
-DocType: Payment Request,Make Sales Invoice,Proveďte prodejní faktuře
+DocType: Payment Request,Make Sales Invoice,Vytvoriť faktúru
 DocType: Company,For Reference Only.,Pouze orientační.
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +49,Invalid {0}: {1},Neplatný {0}: {1}
 DocType: Sales Invoice Advance,Advance Amount,Záloha ve výši
@@ -1829,64 +1701,55 @@
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Nastaviť ako Zatvorené
 apps/erpnext/erpnext/stock/get_item_details.py +113,No Item with Barcode {0},No Položka s čárovým kódem {0}
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Případ č nemůže být 0
-DocType: Features Setup,If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,"Máte-li prodejní tým a prodej Partners (obchodních partnerů), které mohou být označeny a udržovat svůj příspěvek v prodejní činnosti"
 DocType: Item,Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky
-DocType: Item,"Allow in Sales Order of type ""Service""",Povoliť v predajnej objednávke typu &quot;služby&quot;
-apps/erpnext/erpnext/setup/doctype/company/company.py +86,Stores,Obchody
-DocType: Time Log,Projects Manager,Správce projektů
+apps/erpnext/erpnext/stock/doctype/item/item.py +131,Stores,Obchody
 DocType: Serial No,Delivery Time,Dodací lhůta
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Stárnutí dle
 DocType: Item,End of Life,Konec životnosti
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +41,Travel,Cestování
+apps/erpnext/erpnext/demo/setup_data.py +348,Travel,Cestování
 DocType: Leave Block List,Allow Users,Povolit uživatele
 DocType: Purchase Order,Customer Mobile No,Zákazník Mobile Žiadne
 DocType: Sales Invoice,Recurring,Opakujúce sa
 DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Sledovat samostatné výnosy a náklady pro vertikál produktu nebo divizí.
 DocType: Rename Tool,Rename Tool,Nástroj na premenovanie
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +15,Update Cost,Aktualizace Cost
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +23,Update Cost,Aktualizace Cost
 DocType: Item Reorder,Item Reorder,Položka Reorder
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +611,Transfer Material,Přenos materiálu
-apps/erpnext/erpnext/controllers/selling_controller.py +236,Item {0} must be a Sales Item in {1},Bod {0} musí byť Sales Položka {1}
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +695,Transfer Material,Přenos materiálu
 DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Zadejte operací, provozní náklady a dávají jedinečnou operaci ne své operace."
-apps/erpnext/erpnext/public/js/controllers/transaction.js +850,Please set recurring after saving,Prosím nastavte opakujúce sa po uložení
+apps/erpnext/erpnext/public/js/controllers/transaction.js +923,Please set recurring after saving,Prosím nastavte opakujúce sa po uložení
 DocType: Purchase Invoice,Price List Currency,Ceník Měna
 DocType: Naming Series,User must always select,Uživatel musí vždy vybrat
 DocType: Stock Settings,Allow Negative Stock,Povolit Negativní Sklad
 DocType: Installation Note,Installation Note,Poznámka k instalaci
-apps/erpnext/erpnext/public/js/setup_wizard.js +190,Add Taxes,Pridajte dane
+apps/erpnext/erpnext/public/js/setup_wizard.js +216,Add Taxes,Pridajte dane
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38,Cash Flow from Financing,Peňažný tok z finančnej
-,Financial Analytics,Finanční Analýza
 DocType: Quality Inspection,Verified By,Verified By
 DocType: Address,Subsidiary,Dceřiný
 apps/erpnext/erpnext/setup/doctype/company/company.py +61,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nelze změnit výchozí měně společnosti, protože tam jsou stávající transakce. Transakce musí být zrušena, aby změnit výchozí měnu."
 DocType: Quality Inspection,Purchase Receipt No,Číslo příjmky
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Earnest Money
 DocType: Process Payroll,Create Salary Slip,Vytvořit výplatní pásce
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +161,Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +347,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}"
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +352,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: Appraisal,Employee,Zaměstnanec
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +10,Import Email From,Importovať e-maily z
-apps/erpnext/erpnext/utilities/doctype/contact/contact.js +70,Invite as User,Pozvať ako Užívateľ
-DocType: Features Setup,After Sale Installations,Po prodeji instalací
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +111,Please set {0} in Company {1},Prosím nastavte {0} vo firme {1}
+apps/erpnext/erpnext/utilities/doctype/contact/contact.js +71,Invite as User,Pozvať ako Užívateľ
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,{0} {1} is fully billed,{0} {1} je úplne fakturované
 DocType: Workstation Working Hour,End Time,End Time
 apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky pro prodej nebo koupi.
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +75,Group by Voucher,Seskupit podle Poukazu
 apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,predajné Pipeline
-apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Povinné On
 DocType: Sales Invoice,Mass Mailing,Hromadné emaily
 DocType: Rename Tool,File to Rename,Súbor premenovať
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +204,Please select BOM for Item in Row {0},"Prosím, vyberte BOM pre položku v riadku {0}"
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +183,Purchse Order number required for Item {0},Purchse Objednací číslo potřebný k bodu {0}
-apps/erpnext/erpnext/controllers/buying_controller.py +237,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +196,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
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +199,Purchse Order number required for Item {0},Purchse Objednací číslo potřebný k bodu {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +262,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +199,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: Notification Control,Expense Claim Approved,Uhrazení výdajů schváleno
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +113,Pharmaceutical,Farmaceutické
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Náklady na zakoupené zboží
 DocType: Selling Settings,Sales Order Required,Prodejní objednávky Povinné
 DocType: Purchase Invoice,Credit To,Kredit:
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Aktívny Leads / Zákazníci
+apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Aktívne Iniciatívy / Zákazníci
 DocType: Employee Education,Post Graduate,Postgraduální
 DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Plán údržby Detail
 DocType: Quality Inspection Reading,Reading 9,Čtení 9
@@ -1896,22 +1759,18 @@
 DocType: Upload Attendance,Attendance To Date,Účast na data
 DocType: Warranty Claim,Raised By,Vznesené
 DocType: Payment Gateway Account,Payment Account,Platební účet
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +780,Please specify Company to proceed,Uveďte prosím společnost pokračovat
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +761,Please specify Company to proceed,Uveďte prosím společnost pokračovat
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +20,Net Change in Accounts Receivable,Čistá zmena objemu pohľadávok
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +46,Compensatory Off,Vyrovnávací Off
 DocType: Quality Inspection Reading,Accepted,Přijato
 apps/erpnext/erpnext/setup/doctype/company/company.js +46,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"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/utilities/transaction_base.py +93,Invalid reference {0} {1},Neplatná referencie {0} {1}
-DocType: Payment Tool,Total Payment Amount,Celková Částka platby
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +147,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemôže byť väčšie, ako plánované množstvo ({2}), vo Výrobnej Objednávke {3}"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +157,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemôže byť väčšie, ako plánované množstvo ({2}), vo Výrobnej Objednávke {3}"
 DocType: Shipping Rule,Shipping Rule Label,Přepravní Pravidlo Label
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +219,Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +416,"Could not update stock, invoice contains drop shipping item.","Nie je možné aktualizovať zásob, faktúra obsahuje pokles lodnej dopravy tovaru."
-DocType: Newsletter,Test,Test
-apps/erpnext/erpnext/stock/doctype/item/item.py +407,"As there are existing stock transactions for this item, \
-							you can not change the values of 'Has Serial No', 'Has Batch No', 'Is Stock Item' and 'Valuation Method'","Ako tam sú existujúce skladové transakcie pre túto položku, \ nemôžete zmeniť hodnoty &quot;Má sériové číslo&quot;, &quot;má Batch Nie&quot;, &quot;Je skladom&quot; a &quot;ocenenie Method&quot;"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +449,Quick Journal Entry,Rýchly vstup Journal
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +100,You can not change rate if BOM mentioned agianst any item,"Nemůžete změnit sazbu, kdyby BOM zmínil agianst libovolné položky"
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +217,Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +403,"Could not update stock, invoice contains drop shipping item.","Nie je možné aktualizovať zásob, faktúra obsahuje pokles lodnej dopravy tovaru."
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +460,Quick Journal Entry,Rýchly vstup Journal
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +111,You can not change rate if BOM mentioned agianst any item,"Nemůžete změnit sazbu, kdyby BOM zmínil agianst libovolné položky"
 DocType: Employee,Previous Work Experience,Předchozí pracovní zkušenosti
 DocType: Stock Entry,For Quantity,Pre Množstvo
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +209,Please enter Planned Qty for Item {0} at row {1},"Prosím, zadejte Plánované Množství k bodu {0} na řádku {1}"
@@ -1920,17 +1779,16 @@
 DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Samostatná výroba objednávka bude vytvořena pro každého hotového dobrou položku.
 DocType: Purchase Invoice,Terms and Conditions1,Podmínky a podmínek1
 DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Účetní záznam zmrazeny až do tohoto data, nikdo nemůže dělat / upravit položku kromě role uvedeno níže."
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +121,Please save the document before generating maintenance schedule,"Prosím, uložit dokument před generováním plán údržby"
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,"Prosím, uložit dokument před generováním plán údržby"
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Stav projektu
 DocType: UOM,Check this to disallow fractions. (for Nos),"Zkontrolujte, zda to zakázat frakce. (U č)"
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +388,The following Production Orders were created:,Nasledujúce Výrobné zákazky boli vytvorené:
-apps/erpnext/erpnext/config/crm.py +116,Newsletter Mailing List,Newsletter adresár
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +398,The following Production Orders were created:,Nasledujúce Výrobné zákazky boli vytvorené:
 DocType: Delivery Note,Transporter Name,Přepravce Název
 DocType: Authorization Rule,Authorized Value,Autorizovaný Hodnota
 DocType: Contact,Enter department to which this Contact belongs,"Zadejte útvar, který tento kontaktní patří"
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Absent,Celkem Absent
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +734,Item or Warehouse for row {0} does not match Material Request,Položka nebo Warehouse na řádku {0} neodpovídá Materiál Poptávka
-apps/erpnext/erpnext/config/stock.py +185,Unit of Measure,Merná jednotka
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +739,Item or Warehouse for row {0} does not match Material Request,Položka nebo Warehouse na řádku {0} neodpovídá Materiál Poptávka
+apps/erpnext/erpnext/config/stock.py +184,Unit of Measure,Merná jednotka
 DocType: Fiscal Year,Year End Date,Dátum konca roka
 DocType: Task Depends On,Task Depends On,Úloha je závislá na
 DocType: Lead,Opportunity,Příležitost
@@ -1943,7 +1801,7 @@
 DocType: Purchase Receipt,Get Current Stock,Získať aktuálny stav
 apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Strom Bill materiálov
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +151,Mark Present,mark Present
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +189,Maintenance start date can not be before delivery date for Serial No {0},Datum zahájení údržby nemůže být před datem dodání pro pořadové číslo {0}
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +198,Maintenance start date can not be before delivery date for Serial No {0},Datum zahájení údržby nemůže být před datem dodání pro pořadové číslo {0}
 DocType: Production Order,Actual End Date,Skutečné datum ukončení
 DocType: Authorization Rule,Applicable To (Role),Vztahující se na (Role)
 DocType: Stock Entry,Purpose,Účel
@@ -1956,14 +1814,13 @@
 DocType: SMS Log,No of Requested SMS,Počet žádaným SMS
 DocType: Campaign,Campaign-.####,Kampaň-.####
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Ďalšie kroky
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +593,Please supply the specified items at the best possible rates,Prosím dodávať uvedené položky na najlepšie možné ceny
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +676,Please supply the specified items at the best possible rates,Prosím dodávať uvedené položky na najlepšie možné ceny
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +117,Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování
 DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributor / dealer / jednatel / partner / prodejce, který prodává produkty společnosti za provizi."
-DocType: Customer Group,Has Child Node,Má děti Node
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +346,{0} against Purchase Order {1},{0} proti Objednávke {1}
 DocType: SMS Settings,"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Zadejte statické parametry url zde (Např odesílatel = ERPNext, username = ERPNext, password. = 1234 atd.),"
 apps/erpnext/erpnext/accounts/utils.py +42,{0} {1} not in any active Fiscal Year. For more details check {2}.,{0} {1} nie je v žiadnom aktívnom Fiškálnom roku. Pre viac informácií pozrite {2}.
-apps/erpnext/erpnext/setup/setup_wizard/default_website.py +26,This is an example website auto-generated from ERPNext,Toto je príklad webovej stránky automaticky generovanej z ERPNext
+apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +14,This is an example website auto-generated from ERPNext,Toto je príklad webovej stránky automaticky generovanej z ERPNext
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Stárnutí Rozsah 1
 DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
 
@@ -2008,26 +1865,22 @@
  10. Přidat nebo odečítat: Ať už chcete přidat nebo odečíst daň."
 DocType: Purchase Receipt Item,Recd Quantity,Recd Množství
 DocType: Asset Category Account,Asset Category Account,Asset Kategórie Account
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +106,Cannot produce more Item {0} than Sales Order quantity {1},Nelze produkují více položku {0} než prodejní objednávky množství {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +497,Stock Entry {0} is not submitted,Sklad Entry {0} nie je predložená
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +103,Cannot produce more Item {0} than Sales Order quantity {1},Nelze produkují více položku {0} než prodejní objednávky množství {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +504,Stock Entry {0} is not submitted,Sklad Entry {0} nie je predložená
 DocType: Payment Reconciliation,Bank / Cash Account,Bank / Peněžní účet
 DocType: Tax Rule,Billing City,Fakturácia City
 DocType: Global Defaults,Hide Currency Symbol,Skrýt symbol měny
-apps/erpnext/erpnext/config/accounts.py +270,"e.g. Bank, Cash, Credit Card","napríkklad banka, hotovosť, kreditné karty"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +32,"Go to the appropriate group (usually Application of Funds &gt; Current Assets &gt; Bank Accounts and create a new Account (by clicking on Add Child) of type ""Bank""",Prejdite do príslušnej skupiny (obvykle využitie prostriedkov&gt; obežných aktív&gt; bankových účtov a vytvoriť nový účet (kliknutím na Pridať dieťa) typu &quot;Banka&quot;
+apps/erpnext/erpnext/config/accounts.py +283,"e.g. Bank, Cash, Credit Card","napríkklad banka, hotovosť, kreditné karty"
 DocType: Journal Entry,Credit Note,Dobropis
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +218,Completed Qty cannot be more than {0} for operation {1},Dokončenej množstvo nemôže byť viac ako {0} pre prevádzku {1}
-DocType: Features Setup,Quality,Kvalita
 DocType: Warranty Claim,Service Address,Servisní adresy
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +83,Max 100 rows for Stock Reconciliation.,Max 100 řádky pro Stock smíření.
 DocType: Material Request,Manufacture,Výroba
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Dodávka Vezměte prosím na vědomí první
-DocType: Purchase Invoice,Currency and Price List,Mana a cenník
+DocType: Purchase Invoice,Currency and Price List,Cenník a mena
 DocType: Opportunity,Customer / Lead Name,Zákazník / Iniciatíva Meno
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +69,Clearance Date not mentioned,Výprodej Datum není uvedeno
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +71,Production,Výroba
-DocType: Item,Allow Production Order,Povolit výrobní objednávky
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +60,Row {0}:Start Date must be before End Date,"Row {0}: datum zahájení, musí být před koncem roku Datum"
+apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +89,Clearance Date not mentioned,Výprodej Datum není uvedeno
+apps/erpnext/erpnext/config/manufacturing.py +7,Production,Výroba
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +62,Row {0}:Start Date must be before End Date,"Row {0}: datum zahájení, musí být před koncem roku Datum"
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Total (ks)
 DocType: Sales Invoice,This Document,tento dokument
 DocType: Installation Note Item,Installed Qty,Instalované množství
@@ -2035,58 +1888,55 @@
 DocType: Purchase Taxes and Charges,Parenttype,Parenttype
 DocType: Salary Structure,Total Earning,Celkem Zisk
 DocType: Purchase Receipt,Time at which materials were received,"Čas, kdy bylo přijato materiály"
-apps/erpnext/erpnext/utilities/doctype/address/address.py +125,My Addresses,Moje Adresy
 DocType: Stock Ledger Entry,Outgoing Rate,Odchádzajúce Rate
-apps/erpnext/erpnext/config/hr.py +180,Organization branch master.,Organizace větev master.
-apps/erpnext/erpnext/controllers/accounts_controller.py +263, or ,alebo
+apps/erpnext/erpnext/config/hr.py +176,Organization branch master.,Organizace větev master.
+apps/erpnext/erpnext/controllers/accounts_controller.py +273, or ,alebo
 DocType: Sales Order,Billing Status,Status Fakturace
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Utility Expenses,Utility Náklady
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,90-Above,90 Nad
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Utility Expenses,Utility Náklady
+apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90 Nad
 DocType: Buying Settings,Default Buying Price List,Výchozí Nákup Ceník
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +83,No employee for the above selected criteria OR salary slip already created,Žiadny zamestnanec pre vyššie zvolených kritérií alebo výplatnej páske už vytvorili
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +81,No employee for the above selected criteria OR salary slip already created,Žiadny zamestnanec pre vyššie zvolených kritérií alebo výplatnej páske už vytvorili
 DocType: Notification Control,Sales Order Message,Prodejní objednávky Message
 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"
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js +28,Payment Type,Typ platby
+DocType: Payment Entry,Payment Type,Typ platby
 DocType: Process Payroll,Select Employees,Vybrať Zamestnanci
 DocType: Bank Reconciliation,To Date,To Date
 DocType: Opportunity,Potential Sales Deal,Potenciální prodej
 DocType: Purchase Invoice,Total Taxes and Charges,Celkem Daně a poplatky
 DocType: Employee,Emergency Contact,Kontakt v nouzi
 DocType: Item,Quality Parameters,Parametry kvality
-apps/erpnext/erpnext/accounts/doctype/account/account.js +57,Ledger,Účetní kniha
+apps/erpnext/erpnext/accounts/doctype/account/account.js +56,Ledger,Účetní kniha
 DocType: Target Detail,Target  Amount,Cílová částka
 DocType: Shopping Cart Settings,Shopping Cart Settings,Nastavenie Nákupného košíka
 DocType: Journal Entry,Accounting Entries,Účetní záznamy
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplicitní záznam. Zkontrolujte autorizační pravidlo {0}
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +25,Global POS Profile {0} already created for company {1},Global POS Profile {0} už vytvorili pre firmu {1}
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +26,Global POS Profile {0} already created for company {1},Global POS Profile {0} už vytvorili pre firmu {1}
 DocType: Purchase Order,Ref SQ,Ref SQ
 apps/erpnext/erpnext/config/manufacturing.py +74,Replace Item / BOM in all BOMs,Nahradit položky / kusovníky ve všech kusovníků
-DocType: Purchase Order Item,Received Qty,Přijaté Množství
+DocType: Purchase Invoice Item,Received Qty,Přijaté Množství
 DocType: Stock Entry Detail,Serial No / Batch,Výrobní číslo / Batch
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +295,Not Paid and Not Delivered,Nezaplatené a nedoručené
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +297,Not Paid and Not Delivered,Nezaplatené a nedoručené
 DocType: Product Bundle,Parent Item,Nadřazená položka
 DocType: Account,Account Type,Typ účtu
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +113,Leave Type {0} cannot be carry-forwarded,Nechajte typ {0} nemožno vykonávať odovzdávané
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +204,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Plán údržby není generován pro všechny položky. Prosím, klikněte na ""Generovat Schedule"""
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +115,Leave Type {0} cannot be carry-forwarded,Nechajte typ {0} nemožno vykonávať odovzdávané
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +213,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Plán údržby není generován pro všechny položky. Prosím, klikněte na ""Generovat Schedule"""
 ,To Produce,K výrobě
 apps/erpnext/erpnext/config/hr.py +93,Payroll,Mzda
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +119,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pre riadok {0} v {1}. Ak chcete v rýchlosti položku sú {2}, riadky {3} musí byť tiež zahrnuté"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +135,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pre riadok {0} v {1}. Ak chcete v rýchlosti položku sú {2}, riadky {3} musí byť tiež zahrnuté"
 DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikace balíčku pro dodávky (pro tisk)
 DocType: Bin,Reserved Quantity,Vyhrazeno Množství
-DocType: Purchase Invoice,Recurring Ends On,opakujúce sa končí
 DocType: Landed Cost Voucher,Purchase Receipt Items,Položky příjemky
 apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Prispôsobenie Formuláre
 DocType: Account,Income Account,Účet příjmů
-apps/erpnext/erpnext/utilities/doctype/address/address.py +151,No default Address Template found. Please create a new one from Setup &gt; Printing and Branding &gt; Address Template.,Žiadne šablóny východisková adresa nájdený. Prosím vytvorte novú z Nastavenie&gt; Tlač a značky&gt; šablóny adresy.
 DocType: Payment Request,Amount in customer's currency,Čiastka v mene zákazníka
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +697,Delivery,Dodávka
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +705,Delivery,Dodávka
 DocType: Stock Reconciliation Item,Current Qty,Aktuálne Množstvo
 DocType: BOM Item,"See ""Rate Of Materials Based On"" in Costing Section","Viz ""Hodnotit materiálů na bázi"" v kapitole Costing"
 DocType: Appraisal Goal,Key Responsibility Area,Key Odpovědnost Area
 DocType: Item Reorder,Material Request Type,Materiál Typ požadavku
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Row {0}: UOM Conversion Factor is mandatory,Riadok {0}: Konverzný faktor MJ je povinný
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +17,Ref,Ref
-DocType: Cost Center,Cost Center,Nákladové středisko
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +82,Row {0}: UOM Conversion Factor is mandatory,Riadok {0}: Konverzný faktor MJ je povinný
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.html +1,Ref,Ref
+DocType: Budget,Cost Center,Nákladové středisko
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +36,Voucher #,Voucher #
 DocType: Notification Control,Purchase Order Message,Zprávy vydané objenávky
 DocType: Tax Rule,Shipping Country,Prepravné Krajina
@@ -2098,62 +1948,59 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +92,Head of Marketing and Sales,Vedoucí marketingu a prodeje
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +31,Income Tax,Daň z příjmů
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +15,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Je-li zvolena Ceny pravidlo je určen pro ""Cena"", přepíše ceníku. Ceny Pravidlo cena je konečná cena, a proto by měla být použita žádná další sleva. Proto, v transakcích, jako odběratele, objednávky atd, bude stažen v oboru ""sazbou"", spíše než poli ""Ceník sazby""."
-apps/erpnext/erpnext/config/selling.py +168,Track Leads by Industry Type.,Trasa vede od průmyslu typu.
+apps/erpnext/erpnext/config/selling.py +164,Track Leads by Industry Type.,Trasa vede od průmyslu typu.
 DocType: Item Supplier,Item Supplier,Položka Dodavatel
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +326,Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no"
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +708,Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
-apps/erpnext/erpnext/config/selling.py +47,All Addresses.,Všechny adresy.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +360,Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no"
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +727,Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
+apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Všechny adresy.
 DocType: Company,Stock Settings,Nastavenie Skladu
-apps/erpnext/erpnext/accounts/doctype/account/account.py +215,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojenie je možné len vtedy, ak tieto vlastnosti sú rovnaké v oboch záznamoch. Je Group, Root Type, Company"
-apps/erpnext/erpnext/config/crm.py +92,Manage Customer Group Tree.,Správa zákazníků skupiny Tree.
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +301,New Cost Center Name,Názov nového nákladového strediska
+apps/erpnext/erpnext/accounts/doctype/account/account.py +224,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojenie je možné len vtedy, ak tieto vlastnosti sú rovnaké v oboch záznamoch. Je Group, Root Type, Company"
+apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Správa zákazníků skupiny Tree.
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Názov nového nákladového strediska
 DocType: Leave Control Panel,Leave Control Panel,Nechte Ovládací panely
 DocType: Appraisal,HR User,HR User
 DocType: Purchase Invoice,Taxes and Charges Deducted,Daně a odečtené
-apps/erpnext/erpnext/hooks.py +90,Issues,Problémy
-apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Stav musí být jedním z {0}
+apps/erpnext/erpnext/hooks.py +100,Issues,Problémy
+apps/erpnext/erpnext/controllers/status_updater.py +13,Status must be one of {0},Stav musí být jedním z {0}
 DocType: Sales Invoice,Debit To,Debetní K
 DocType: Delivery Note,Required only for sample item.,Požadováno pouze pro položku vzorku.
 DocType: Stock Ledger Entry,Actual Qty After Transaction,Skutečné Množství Po transakci
 ,Pending SO Items For Purchase Request,"Do doby, než SO položky k nákupu Poptávka"
-apps/erpnext/erpnext/accounts/party.py +322,{0} {1} is disabled,{0} {1} je zakázaný
+apps/erpnext/erpnext/accounts/party.py +345,{0} {1} is disabled,{0} {1} je zakázaný
 DocType: Supplier,Billing Currency,Mena fakturácie
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +148,Extra Large,Extra Veľké
-,Profit and Loss Statement,Výkaz zisků a ztrát
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +157,Extra Large,Extra Veľké
+,Profit and Loss Statement,Výkaz ziskov a strát
 DocType: Bank Reconciliation Detail,Cheque Number,Šek číslo
-DocType: Payment Tool Detail,Payment Tool Detail,Detail platební nástroj
 ,Sales Browser,Sales Browser
 DocType: Journal Entry,Total Credit,Celkový Credit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +500,Warning: Another {0} # {1} exists against stock entry {2},Upozornenie: Ďalším {0} # {1} existuje proti akciovej vstupu {2}
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +362,Local,Místní
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +507,Warning: Another {0} # {1} exists against stock entry {2},Upozornenie: Ďalším {0} # {1} existuje proti akciovej vstupu {2}
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +109,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/install_fixtures.py +147,Large,Veľký
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +156,Large,Veľký
 DocType: C-Form Invoice Detail,Territory,Území
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +143,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +152,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
 DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
 DocType: Production Order Operation,Planned Start Time,Plánované Start Time
-apps/erpnext/erpnext/config/accounts.py +222,Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
+DocType: Payment Entry Reference,Allocated,Přidělené
+apps/erpnext/erpnext/config/accounts.py +225,Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
 DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Zadejte Exchange Rate převést jednu měnu na jinou
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +142,Quotation {0} is cancelled,Ponuka {0} je zrušená
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +26,Total Outstanding Amount,Celková dlužná částka
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +145,Quotation {0} is cancelled,Ponuka {0} je zrušená
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.html +1,Total Outstanding Amount,Celková dlužná částka
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} was on leave on {1}. Cannot mark attendance.,Zaměstnanec {0} byl na dovolené na {1}. Nelze označit účast.
 DocType: Sales Partner,Targets,Cíle
 DocType: Price List,Price List Master,Ceník Master
 DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Všechny prodejní transakce mohou být označeny proti více ** prodejcům **, takže si můžete nastavit a sledovat cíle."
 ,S.O. No.,SO Ne.
-DocType: Production Order Operation,Make Time Log,Udělejte si čas Přihlásit
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +154,Please create Customer from Lead {0},Prosím vytvorte Zákazníka z Obchodnej iniciatívy {0}
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +150,Please create Customer from Lead {0},Prosím vytvorte Zákazníka z Obchodnej iniciatívy {0}
 DocType: Price List,Applicable for Countries,Pre krajiny
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Computers,Počítače
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +14,This is a root customer group and cannot be edited.,"To je kořen skupiny zákazníků, a nelze upravovat."
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +39,Please setup your chart of accounts before you start Accounting Entries,"Prosím, nastavit svůj účtový rozvrh, než začnete účetních zápisů"
-DocType: Purchase Invoice,Ignore Pricing Rule,Ignorovat Ceny pravidlo
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +91,From Date in Salary Structure cannot be lesser than Employee Joining Date.,Od dátum vo mzdovú štruktúru nemôže byť menšia ako zamestnancov Spájanie Date.
+apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,"To je kořen skupiny zákazníků, a nelze upravovat."
+DocType: POS Profile,Ignore Pricing Rule,Ignorovat Ceny pravidlo
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +92,From Date in Salary Structure cannot be lesser than Employee Joining Date.,Od dátum vo mzdovú štruktúru nemôže byť menšia ako zamestnancov Spájanie Date.
 DocType: Employee Education,Graduate,Absolvent
 DocType: Leave Block List,Block Days,Blokové dny
 DocType: Journal Entry,Excise Entry,Spotřební Entry
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +63,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozornenie: predajné objednávky {0} už existuje proti Zákazníka objednanie {1}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +66,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozornenie: predajné objednávky {0} už existuje proti Zákazníka objednanie {1}
 DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
 
 Examples:
@@ -2180,284 +2027,256 @@
  1. Způsoby řešení sporů, náhrady škody, odpovědnosti za škodu, atd 
  1. Adresa a kontakt na vaši společnost."
 DocType: Attendance,Leave Type,Leave Type
-apps/erpnext/erpnext/controllers/stock_controller.py +173,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Náklady / Rozdíl účtu ({0}), musí být ""zisk nebo ztráta"" účet"
+apps/erpnext/erpnext/controllers/stock_controller.py +172,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Náklady / Rozdíl účtu ({0}), musí být ""zisk nebo ztráta"" účet"
 DocType: Account,Accounts User,Uživatel Účtů
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,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)
 DocType: C-Form Invoice Detail,Net Total,Netto Spolu
 DocType: Bin,FCFS Rate,FCFS Rate
-apps/erpnext/erpnext/accounts/page/pos/pos.js +15,Billing (Sales Invoice),Fakturace (Prodejní Faktura)
 DocType: Payment Reconciliation Invoice,Outstanding Amount,Dlužné částky
 DocType: Project Task,Working,Pracovní
 DocType: Stock Ledger Entry,Stock Queue (FIFO),Sklad fronty (FIFO)
-apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +24,Please select Time Logs.,Vyberte Time Protokoly.
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +37,{0} does not belong to Company {1},{0} nepatrí do Spoločnosti {1}
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +38,{0} does not belong to Company {1},{0} nepatrí do Spoločnosti {1}
 DocType: Account,Round Off,Zaokrúhliť
 ,Requested Qty,Požadované množství
 DocType: Tax Rule,Use for Shopping Cart,Použitie pre Košík
 DocType: BOM Item,Scrap %,Scrap%
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +38,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Poplatky budou rozděleny úměrně na základě položky Množství nebo částkou, dle Vašeho výběru"
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +45,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Poplatky budou rozděleny úměrně na základě položky Množství nebo částkou, dle Vašeho výběru"
 DocType: Maintenance Visit,Purposes,Cíle
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +109,Atleast one item should be entered with negative quantity in return document,Aspon jedna položka by mala byť zadaná s negatívnym množstvo vo vratnom dokumente
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +67,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Prevádzka {0} dlhšie, než všetkých dostupných pracovných hodín v pracovnej stanici {1}, rozložiť prevádzku do niekoľkých operácií"
 ,Requested,Požadované
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +68,No Remarks,Žiadne poznámky
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +83,No Remarks,Žiadne poznámky
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +13,Overdue,Zpožděný
 DocType: Account,Stock Received But Not Billed,Sklad nepřijali Účtovaný
-apps/erpnext/erpnext/accounts/doctype/account/account.py +83,Root Account must be a group,Root účet musí byť skupina
+apps/erpnext/erpnext/accounts/doctype/account/account.py +87,Root Account must be a group,Root účet musí byť skupina
 DocType: Salary Slip,Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Gross Pay + nedoplatek Částka + Inkaso Částka - Total Odpočet
-DocType: Monthly Distribution,Distribution Name,Distribuce Name
-DocType: Features Setup,Sales and Purchase,Prodej a nákup
-apps/erpnext/erpnext/stock/doctype/item/item.py +574,Fixed Asset Item must be a non-stock item,Fixed Asset položky musia byť non-skladová položka
-DocType: Supplier Quotation Item,Material Request No,Materiál Poptávka No
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +211,Quality Inspection required for Item {0},Kontrola kvality potřebný k bodu {0}
+DocType: Monthly Distribution,Distribution Name,Názov distribúcie
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +98,Quality Inspection required for Item {0},Kontrola kvality potřebný k bodu {0}
 DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Sazba, za kterou zákazník měny je převeden na společnosti základní měny"
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +107,{0} has been successfully unsubscribed from this list.,{0} bol úspešne odhlásený z tohto zoznamu.
 DocType: Purchase Invoice Item,Net Rate (Company Currency),Čistý Rate (Company meny)
-apps/erpnext/erpnext/config/crm.py +101,Manage Territory Tree.,Správa Territory strom.
+apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Správa Territory strom.
 DocType: Journal Entry Account,Sales Invoice,Prodejní faktury
 DocType: Journal Entry Account,Party Balance,Balance Party
-DocType: Sales Invoice Item,Time Log Batch,Time Log Batch
-apps/erpnext/erpnext/public/js/controllers/taxes_and_totals.js +442,Please select Apply Discount On,"Prosím, vyberte Použiť Zľava na"
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +85,Salary Slip Created,Plat Slip Vytvorené
+apps/erpnext/erpnext/accounts/page/pos/pos.js +475,Please select Apply Discount On,"Prosím, vyberte Použiť Zľava na"
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +83,Salary Slip Created,Plat Slip Vytvorené
 DocType: Company,Default Receivable Account,Výchozí pohledávek účtu
 DocType: Process Payroll,Create Bank Entry for the total salary paid for the above selected criteria,Vytvoření bankovní položka pro celkové vyplacené mzdy za výše zvolených kritérií
 DocType: Stock Entry,Material Transfer for Manufacture,Materiál Přenos: Výroba
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +18,Discount Percentage can be applied either against a Price List or for all Price List.,Sleva v procentech lze použít buď proti Ceníku nebo pro všechny Ceníku.
 DocType: Purchase Invoice,Half-yearly,Pololetní
 apps/erpnext/erpnext/accounts/report/financial_statements.py +16,Fiscal Year {0} not found.,Fiskální rok {0} nebyl nalezen.
-DocType: Bank Reconciliation,Get Relevant Entries,Získat příslušné zápisy
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407,Accounting Entry for Stock,Účetní položka na skladě
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +384,Accounting Entry for Stock,Účetní položka na skladě
 DocType: Sales Invoice,Sales Team1,Sales Team1
-apps/erpnext/erpnext/stock/doctype/item/item.py +454,Item {0} does not exist,Bod {0} neexistuje
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +37,Item {0} does not exist,Bod {0} neexistuje
 DocType: Sales Invoice,Customer Address,Zákazník Address
-DocType: Payment Request,Recipient and Message,Príjemca a správ
 DocType: Purchase Invoice,Apply Additional Discount On,Použiť dodatočné Zľava na
 DocType: Account,Root Type,Root Type
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Cannot return more than {1} for Item {2},Riadok # {0}: Nemožno vrátiť viac ako {1} pre bodu {2}
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +52,Plot,Spiknutí
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88,Row # {0}: Cannot return more than {1} for Item {2},Riadok # {0}: Nemožno vrátiť viac ako {1} pre bodu {2}
+apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +76,Plot,Spiknutí
 DocType: Item Group,Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky
 DocType: BOM,Item UOM,MJ položky
 DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Suma dane po zľave Suma (Company meny)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +148,Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +147,Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
 DocType: Purchase Invoice,Select Supplier Address,Vybrať Dodávateľ Address
 DocType: Quality Inspection,Quality Inspection,Kontrola kvality
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +144,Extra Small,Extra Malé
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +582,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í
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +190,Account {0} is frozen,Účet {0} je zmrazen
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +153,Extra Small,Extra Malé
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +666,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í
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +194,Account {0} is frozen,Účet {0} je zmrazen
 DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Právní subjekt / dceřiná společnost s oddělenou Graf účtů, které patří do organizace."
 DocType: Payment Request,Mute Email,Mute Email
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +29,"Food, Beverage & Tobacco","Potraviny, nápoje a tabák"
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +20,PL or BS,PL nebo BS
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +557,Can only make payment against unbilled {0},Možno vykonať len platbu proti nevyfakturované {0}
-apps/erpnext/erpnext/controllers/selling_controller.py +122,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Minimum Inventory Level,Minimální úroveň zásob
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +600,Can only make payment against unbilled {0},Možno vykonať len platbu proti nevyfakturované {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +126,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
 DocType: Stock Entry,Subcontract,Subdodávka
-apps/erpnext/erpnext/public/js/utils/party.js +124,Please enter {0} first,"Prosím, zadajte {0} ako prvý"
+apps/erpnext/erpnext/public/js/utils/party.js +145,Please enter {0} first,"Prosím, zadajte {0} ako prvý"
 DocType: Production Order Operation,Actual End Time,Aktuální End Time
 DocType: Production Planning Tool,Download Materials Required,Ke stažení potřebné materiály:
 DocType: Item,Manufacturer Part Number,Typové označení
 DocType: Production Order Operation,Estimated Time and Cost,Odhadovná doba a náklady
 DocType: Bin,Bin,Popelnice
 DocType: SMS Log,No of Sent SMS,Počet odeslaných SMS
-DocType: Account,Company,Spoločnosť
 DocType: Account,Expense Account,Účtet nákladů
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,Software
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +151,Colour,Farebné
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +160,Colour,Farebné
 DocType: Maintenance Visit,Scheduled,Plánované
 apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Žiadosť o cenovú ponuku.
 apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Prosím, vyberte položku, kde &quot;Je skladom,&quot; je &quot;Nie&quot; a &quot;je Sales Item&quot; &quot;Áno&quot; a nie je tam žiadny iný produkt Bundle"
-apps/erpnext/erpnext/controllers/accounts_controller.py +418,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celkové zálohy ({0}) na objednávku {1} nemôže byť väčšia ako Celkom ({2})
+apps/erpnext/erpnext/controllers/accounts_controller.py +469,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celkové zálohy ({0}) na objednávku {1} nemôže byť väčšia ako Celkom ({2})
 DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Vyberte měsíční výplatou na nerovnoměrně distribuovat cílů napříč měsíců.
 DocType: Purchase Invoice Item,Valuation Rate,Ocenění Rate
-apps/erpnext/erpnext/stock/get_item_details.py +293,Price List Currency not selected,Ceníková Měna není zvolena
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,"Bod Row {0}: doklad o koupi, {1} neexistuje v tabulce ""kupní příjmy"""
+apps/erpnext/erpnext/stock/get_item_details.py +294,Price List Currency not selected,Ceníková Měna není zvolena
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +158,Employee {0} has already applied for {1} between {2} and {3},Zaměstnanec {0} již požádal o {1} mezi {2} a {3}
 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 +8,Until,Dokud
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.html +1,Until,Dokud
 DocType: Rename Tool,Rename Log,Premenovať Log
-DocType: Installation Note Item,Against Document No,Proti dokumentu č
-apps/erpnext/erpnext/config/selling.py +113,Manage Sales Partners.,Správa prodejních partnerů.
+DocType: Maintenance Visit Purpose,Against Document No,Proti dokumentu č
+apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Správa prodejních partnerů.
 DocType: Quality Inspection,Inspection Type,Kontrola Type
 apps/erpnext/erpnext/controllers/recurring_document.py +166,Please select {0},"Prosím, vyberte {0}"
 DocType: C-Form,C-Form No,C-Form No
 DocType: BOM,Exploded_items,Exploded_items
 DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačené Návštevnosť
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +95,Researcher,Výzkumník
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +78,Please save the Newsletter before sending,Uložte Newsletter před odesláním
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Meno alebo e-mail je povinné
-apps/erpnext/erpnext/config/stock.py +159,Incoming quality inspection.,Vstupní kontrola jakosti.
+apps/erpnext/erpnext/config/stock.py +158,Incoming quality inspection.,Vstupní kontrola jakosti.
 DocType: Purchase Order Item,Returned Qty,Vrátené Množstvo
 DocType: Employee,Exit,Východ
-apps/erpnext/erpnext/accounts/doctype/account/account.py +155,Root Type is mandatory,Root Type je povinné
+apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Root Type is mandatory,Root Type je povinné
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +295,Serial No {0} created,Pořadové číslo {0} vytvořil
 DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pro pohodlí zákazníků, tyto kódy mohou být použity v tiskových formátech, jako na fakturách a dodacích listech"
 DocType: Employee,You can enter any date manually,Můžete zadat datum ručně
 DocType: Sales Invoice,Advertisement,Reklama
 DocType: Asset Category Account,Depreciation Expense Account,Odpisy Náklady účtu
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +165,Probationary Period,Skúšobná doba
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +174,Probationary Period,Skúšobná doba
 DocType: Customer Group,Only leaf nodes are allowed in transaction,Pouze koncové uzly jsou povoleny v transakci
 DocType: Expense Claim,Expense Approver,Schvalovatel výdajů
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +109,Row {0}: Advance against Customer must be credit,Riadok {0}: Advance proti zákazník musí byť úver
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané
-apps/erpnext/erpnext/public/js/pos/pos.js +356,Pay,Platiť
-apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +17,To Datetime,Chcete-li datetime
+DocType: Payment Entry,Pay,Platiť
+apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +16,To Datetime,Chcete-li datetime
 DocType: SMS Settings,SMS Gateway URL,SMS brána URL
-apps/erpnext/erpnext/config/crm.py +132,Logs for maintaining sms delivery status,Protokoly pre udržanie stavu doručenia sms
+apps/erpnext/erpnext/config/selling.py +283,Logs for maintaining sms delivery status,Protokoly pre udržanie stavu doručenia sms
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +36,Pending Activities,Nevybavené Aktivity
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +166,Confirmed,Potvrdené
 DocType: Payment Gateway,Gateway,Brána
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +131,Please enter relieving date.,Zadejte zmírnění datum.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +127,Please enter relieving date.,Zadejte zmírnění datum.
 apps/erpnext/erpnext/controllers/trends.py +145,Amt,Amt
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +53,Only Leave Applications with status 'Approved' can be submitted,"Nechte pouze aplikace s status ""schváleno"" může být předloženy"
-apps/erpnext/erpnext/utilities/doctype/address/address.py +25,Address Title is mandatory.,Adresa Název je povinný.
+apps/erpnext/erpnext/utilities/doctype/address/address.py +26,Address Title is mandatory.,Názov adresy je povinný.
 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/industry_type.py +38,Newspaper Publishers,Vydavatelia novín
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +31,Select Fiscal Year,Vyberte Fiskální rok
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Změna pořadí Level
 DocType: Attendance,Attendance Date,Účast Datum
 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 +127,Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu
+apps/erpnext/erpnext/accounts/doctype/account/account.py +131,Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu
 DocType: Address,Preferred Shipping Address,Preferovaná dodací adresa
-DocType: Purchase Receipt Item,Accepted Warehouse,Schválené Sklad
+DocType: Purchase Invoice Item,Accepted Warehouse,Schválené Sklad
 DocType: Bank Reconciliation Detail,Posting Date,Datum zveřejnění
 DocType: Item,Valuation Method,Ocenění Method
-apps/erpnext/erpnext/setup/utils.py +93,Unable to find exchange rate for {0} to {1},Nepodarilo sa nájsť kurz pre {0} do {1}
+apps/erpnext/erpnext/setup/utils.py +96,Unable to find exchange rate for {0} to {1},Nepodarilo sa nájsť kurz pre {0} do {1}
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +202,Mark Half Day,Mark Poldenné
 DocType: Sales Invoice,Sales Team,Prodejní tým
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +88,Duplicate entry,Duplicitní záznam
 DocType: Serial No,Under Warranty,V rámci záruky
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +413,[Error],[Chyba]
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +447,[Error],[Chyba]
 DocType: Sales Order,In Words will be visible once you save the Sales Order.,"Ve slovech budou viditelné, jakmile uložíte prodejní objednávky."
 ,Employee Birthday,Narozeniny zaměstnance
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,Venture Capital
 DocType: UOM,Must be Whole Number,Musí být celé číslo
 DocType: Leave Control Panel,New Leaves Allocated (In Days),Nové Listy Přidělené (ve dnech)
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Pořadové číslo {0} neexistuje
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +52,Supplier &gt; Supplier Type,Dodávateľ&gt; Dodávateľ Type
 DocType: Sales Invoice Item,Customer Warehouse (Optional),Zákazník Warehouse (voliteľne)
 DocType: Pricing Rule,Discount Percentage,Sleva v procentech
 DocType: Payment Reconciliation Invoice,Invoice Number,Číslo faktúry
 DocType: Shopping Cart Settings,Orders,Objednávky
-DocType: Leave Control Panel,Employee Type,Type zaměstnanců
-DocType: Features Setup,To maintain the customer wise item code and to make them searchable based on their code use this option,Pre udržanie zákazníka múdry Kód tovaru a aby ich vyhľadávať na základe ich použitia kódu Túto voľbu
 DocType: Employee Leave Approver,Leave Approver,Nechte schvalovač
 DocType: Manufacturing Settings,Material Transferred for Manufacture,Prevádza jadrový materiál pre Výroba
 DocType: Expense Claim,"A user with ""Expense Approver"" role","Uživatel s rolí ""Schvalovatel výdajů"""
 ,Issued Items Against Production Order,Vydané předmětů proti výrobní zakázky
 DocType: Pricing Rule,Purchase Manager,Vedoucí nákupu
-DocType: Payment Tool,Payment Tool,Platebního nástroje
 DocType: Target Detail,Target Detail,Target Detail
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +20,All Jobs,všetky Jobs
+apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +25,All Jobs,všetky Jobs
 DocType: Sales Order,% of materials billed against this Sales Order,% Materiálov fakturovaných proti tejto Predajnej objednávke
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +50,Period Closing Entry,Období Uzávěrka Entry
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +62,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/report/trial_balance/trial_balance.js +49,Period Closing Entry,Období Uzávěrka Entry
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,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
 DocType: Account,Depreciation,Znehodnocení
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Dodavatel (é)
 DocType: Employee Attendance Tool,Employee Attendance Tool,Účasť zamestnancov Tool
 DocType: Supplier,Credit Limit,Úvěrový limit
 DocType: Production Plan Sales Order,Salse Order Date,Salse Dátum objednávky
-apps/erpnext/erpnext/accounts/page/pos/pos_page.html +4,Select type of transaction,Vyberte typ transakce
 DocType: GL Entry,Voucher No,Voucher No
 DocType: Leave Allocation,Leave Allocation,Nechte Allocation
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +474,Material Requests {0} created,Materiál Žádosti {0} vytvořené
-apps/erpnext/erpnext/config/selling.py +158,Template of terms or contract.,Šablona podmínek nebo smlouvy.
+apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +481,Material Requests {0} created,Materiál Žádosti {0} vytvořené
+apps/erpnext/erpnext/config/selling.py +154,Template of terms or contract.,Šablona podmínek nebo smlouvy.
 DocType: Purchase Invoice,Address and Contact,Adresa a Kontakt
 DocType: Supplier,Last Day of the Next Month,Posledný deň nasledujúceho mesiaca
 DocType: Employee,Feedback,Zpětná vazba
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +66,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Dovolenka nemôže byť pridelené pred {0}, pretože rovnováha dovolenky už bolo carry-odovzdávané v budúcej pridelenie dovolenku záznamu {1}"
-apps/erpnext/erpnext/accounts/party.py +286,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Poznámka: Z důvodu / Referenční datum překračuje povolené zákazníků úvěrové dní od {0} den (s)
+apps/erpnext/erpnext/accounts/party.py +305,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Poznámka: Z důvodu / Referenční datum překračuje povolené zákazníků úvěrové dní od {0} den (s)
 DocType: Asset Category Account,Accumulated Depreciation Account,účet oprávok
 DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Příspěvky
 DocType: Asset,Expected Value After Useful Life,Očakávaná hodnota po celú dobu životnosti
 DocType: Item,Reorder level based on Warehouse,Úroveň Zmena poradia na základe Warehouse
-DocType: Activity Cost,Billing Rate,Fakturácia Rate
+DocType: Activity Cost,Billing Rate,Fakturačná cena
 ,Qty to Deliver,Množství k dodání
 DocType: Monthly Distribution Percentage,Month,Měsíc
 ,Stock Analytics,Stock Analytics
-DocType: Installation Note Item,Against Document Detail No,Proti Detail dokumentu č
+DocType: Maintenance Visit Purpose,Against Document Detail No,Proti Detail dokumentu č
 DocType: Quality Inspection,Outgoing,Vycházející
 DocType: Material Request,Requested For,Požadovaných pro
 DocType: Quotation Item,Against Doctype,Proti DOCTYPE
-apps/erpnext/erpnext/controllers/stock_controller.py +248,{0} {1} is cancelled or closed,{0} {1} je zrušený alebo zatvorené
+apps/erpnext/erpnext/controllers/buying_controller.py +376,{0} {1} is cancelled or closed,{0} {1} je zrušený alebo zatvorené
 DocType: Delivery Note,Track this Delivery Note against any Project,Sledovat tento dodacím listu proti jakémukoli projektu
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28,Net Cash from Investing,Čistý peňažný tok z investičnej
 ,Is Primary Address,Je Hlavný adresa
 DocType: Production Order,Work-in-Progress Warehouse,Work-in-Progress sklad
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +99,Asset {0} must be submitted,Asset {0} musí byť predložené
+apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +104,Asset {0} must be submitted,Asset {0} musí byť predložené
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +324,Reference #{0} dated {1},Reference # {0} ze dne {1}
-apps/erpnext/erpnext/templates/includes/cart/cart_address.html +16,Manage Addresses,Správa adries
+apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Správa adries
 DocType: Asset,Item Code,Kód položky
 DocType: Production Planning Tool,Create Production Orders,Vytvoření výrobní zakázky
 DocType: Serial No,Warranty / AMC Details,Záruka / AMC Podrobnosti
 DocType: Journal Entry,User Remark,Uživatel Poznámka
 DocType: Lead,Market Segment,Segment trhu
 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 +226,Closing (Dr),Uzavření (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +233,Closing (Dr),Uzavření (Dr)
 DocType: Contact,Passive,Pasivní
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +228,Serial No {0} not in stock,Pořadové číslo {0} není skladem
-apps/erpnext/erpnext/config/selling.py +163,Tax template for selling transactions.,Daňové šablona na prodej transakce.
-DocType: Sales Invoice,Write Off Outstanding Amount,Odepsat dlužné částky
-DocType: Features Setup,"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Zkontrolujte, zda potřebujete automatické opakující faktury. Po odeslání jakékoliv prodejní fakturu, opakující se část bude viditelný."
-DocType: Account,Accounts Manager,Accounts Manager
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +39,Time Log {0} must be 'Submitted',"Time Log {0} musí být ""Odesláno"""
+apps/erpnext/erpnext/config/selling.py +159,Tax template for selling transactions.,Daňové šablona na prodej transakce.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1351,Write Off Outstanding Amount,Odepsat dlužné částky
+DocType: Account,Accounts Manager,Manažér účtov
 DocType: Stock Settings,Default Stock UOM,Východzia skladová MJ
-DocType: Time Log,Costing Rate based on Activity Type (per hour),Kalkulácia Hodnotiť založené na typ aktivity (za hodinu)
 DocType: Production Planning Tool,Create Material Requests,Vytvořit Žádosti materiálu
 DocType: Employee Education,School/University,Škola / University
 DocType: Payment Request,Reference Details,Odkaz Podrobnosti
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +37,Expected Value After Useful Life must be less than Gross Purchase Amount,Očakávaná hodnota Po celú dobu životnosti musí byť menšie ako Gross sumy nákupu
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +57,Expected Value After Useful Life must be less than Gross Purchase Amount,Očakávaná hodnota Po celú dobu životnosti musí byť menšie ako Gross sumy nákupu
 DocType: Sales Invoice Item,Available Qty at Warehouse,Množství k dispozici na skladu
 ,Billed Amount,Fakturovaná částka
 DocType: Asset,Double Declining Balance,double degresívne
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +163,Closed order cannot be cancelled. Unclose to cancel.,Uzavretá objednávka nemôže byť zrušený. Otvoriť zrušiť.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +166,Closed order cannot be cancelled. Unclose to cancel.,Uzavretá objednávka nemôže byť zrušený. Otvoriť zrušiť.
 DocType: Bank Reconciliation,Bank Reconciliation,Bank Odsouhlasení
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +9,Get Updates,Získať aktualizácie
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +135,Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena
-apps/erpnext/erpnext/public/js/setup_wizard.js +287,Add a few sample records,Pridať niekoľko ukážkových záznamov
-apps/erpnext/erpnext/config/hr.py +247,Leave Management,Nechajte Správa
+apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Získať aktualizácie
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +132,Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena
+apps/erpnext/erpnext/public/js/setup_wizard.js +313,Add a few sample records,Pridať niekoľko ukážkových záznamov
+apps/erpnext/erpnext/config/hr.py +243,Leave Management,Správa priepustiek
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +81,Group by Account,Seskupit podle účtu
 DocType: Sales Order,Fully Delivered,Plně Dodáno
 DocType: Lead,Lower Income,S nižšími příjmy
 DocType: Period Closing Voucher,"The account head under Liability, in which Profit/Loss will be booked","Účet hlavu pod odpovědnosti, ve kterém se bude Zisk / ztráta rezervovali"
-DocType: Payment Tool,Against Vouchers,Proti Poukázky
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +23,Quick Help,Rychlá pomoc
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +167,Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
-DocType: Features Setup,Sales Extras,Prodejní Extras
-apps/erpnext/erpnext/accounts/utils.py +346,{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} rozpočet pre účet {1} proti nákladovému stredisku {2} prekročí o {3}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +166,Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +242,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Rozdiel účet musí byť typu aktív / Zodpovednosť účet, pretože to Reklamná Zmierenie je Entry Otvorenie"
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +131,Purchase Order number required for Item {0},Číslo vydané objednávky je potřebné k položce {0}
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +81,Purchase Order number required for Item {0},Číslo vydané objednávky je potřebné k položce {0}
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',"""Dátum DO"" musí byť po ""Dátum OD"""
 DocType: Asset,Fully Depreciated,plne odpísaný
 ,Stock Projected Qty,Reklamní Plánovaná POČET
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +137,Customer {0} does not belong to project {1},Zákazník {0} nepatří k projektu {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +351,Customer {0} does not belong to project {1},Zákazník {0} nepatří k projektu {1}
 DocType: Employee Attendance Tool,Marked Attendance HTML,Výrazná Účasť HTML
 DocType: Sales Order,Customer's Purchase Order,Zákazníka Objednávka
-apps/erpnext/erpnext/config/stock.py +108,Serial No and Batch,Poradové číslo a Batch
+apps/erpnext/erpnext/config/stock.py +107,Serial No and Batch,Poradové číslo a Batch
 DocType: Warranty Claim,From Company,Od Společnosti
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +95,Value or Qty,Hodnota nebo Množství
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +390,Productions Orders cannot be raised for:,Productions Objednávky nemôže byť zvýšená pre:
-apps/erpnext/erpnext/public/js/setup_wizard.js +273,Minute,Minúta
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +400,Productions Orders cannot be raised for:,Productions Objednávky nemôže byť zvýšená pre:
+apps/erpnext/erpnext/public/js/setup_wizard.js +299,Minute,Minúta
 DocType: Purchase Invoice,Purchase Taxes and Charges,Nákup Daně a poplatky
 ,Qty to Receive,Množství pro příjem
 DocType: Leave Block List,Leave Block List Allowed,Nechte Block List povolena
 DocType: Sales Partner,Retailer,Maloobchodník
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +101,Credit To account must be a Balance Sheet account,Pripísať na účet musí byť účtu Súvaha
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +105,Credit To account must be a Balance Sheet account,Pripísať na účet musí byť účtu Súvaha
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +128,All Supplier Types,Všechny typy Dodavatele
 DocType: Global Defaults,Disable In Words,Zakázať v slovách
-apps/erpnext/erpnext/stock/doctype/item/item.py +46,Item Code is mandatory because Item is not automatically numbered,"Kód položky je povinné, protože položka není automaticky číslovány"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +94,Quotation {0} not of type {1},Ponuka {0} nie je typu {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +45,Item Code is mandatory because Item is not automatically numbered,"Kód položky je povinné, protože položka není automaticky číslovány"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +97,Quotation {0} not of type {1},Ponuka {0} nie je typu {1}
 DocType: Maintenance Schedule Item,Maintenance Schedule Item,Plán údržby Item
 DocType: Sales Order,%  Delivered,% Dodaných
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +180,Bank Overdraft Account,Kontokorentní úvěr na účtu
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +46,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; položka Group&gt; Brand
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +18,Browse BOM,Prechádzať BOM
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +178,Secured Loans,Zajištěné úvěry
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +89,Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosím, amortizácia účty s ním súvisiacich v kategórii Asset {0} alebo {1} Company"
-apps/erpnext/erpnext/setup/setup_wizard/data/sample_home_page.html +3,Awesome Products,Skvelé produkty
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +192,Opening Balance Equity,Počiatočný stav Equity
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Bank Overdraft Account,Kontokorentní úvěr na účtu
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +47,Make Salary Slip,Proveďte výplatní pásce
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +26,Browse BOM,Prechádzať BOM
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Secured Loans,Zajištěné úvěry
+apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +94,Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosím, amortizácia účty s ním súvisiacich v kategórii Asset {0} alebo {1} Company"
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Opening Balance Equity,Počiatočný stav Equity
 DocType: Appraisal,Appraisal,Ocenění
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +102,Email sent to supplier {0},E-mailu zaslaného na dodávateľa {0}
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +136,Email sent to supplier {0},E-mailu zaslaného na dodávateľa {0}
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Datum se opakuje
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Prokurista
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +187,Leave approver must be one of {0},Nechte Schvalující musí být jedním z {0}
@@ -2465,32 +2284,30 @@
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Celkové obstarávacie náklady (cez nákupné faktúry)
 DocType: Workstation Working Hour,Start Time,Start Time
 DocType: Item Price,Bulk Import Help,Bulk import Help
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +200,Select Quantity,Zvolte množství
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +256,Select Quantity,Zvolte množství
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Schválení role nemůže být stejná jako role pravidlo se vztahuje na
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +66,Unsubscribe from this Email Digest,Odhlásiť sa z tohto Email Digest
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +65,Unsubscribe from this Email Digest,Odhlásiť sa z tohto Email Digest
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Správa bola odoslaná
-apps/erpnext/erpnext/accounts/doctype/account/account.py +97,Account with child nodes cannot be set as ledger,Účet s podriadené uzly nie je možné nastaviť ako hlavnej knihy
+apps/erpnext/erpnext/accounts/doctype/account/account.py +101,Account with child nodes cannot be set as ledger,Účet s podriadené uzly nie je možné nastaviť ako hlavnej knihy
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou Ceník měna je převeden na zákazníka základní měny"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá suma (Company Mena)
-DocType: BOM Operation,Hour Rate,Hodinová sadzba
+DocType: Salary Slip,Hour Rate,Hodinová sadzba
 DocType: Stock Settings,Item Naming By,Položka Pojmenování By
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Další období Uzávěrka Entry {0} byla podána po {1}
 DocType: Production Order,Material Transferred for Manufacturing,Materiál Prenesená pre výrobu
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +29,Account {0} does not exists,Účet {0} neexistuje
-DocType: Purchase Receipt Item,Purchase Order Item No,Číslo položky vydané objednávky
 DocType: Project,Project Type,Typ projektu
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Buď cílové množství nebo cílová částka je povinná.
-apps/erpnext/erpnext/config/projects.py +50,Cost of various activities,Náklady na rôznych aktivít
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +103,Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0}
-DocType: Item,Inspection Required,Kontrola Povinné
+apps/erpnext/erpnext/config/projects.py +45,Cost of various activities,Náklady na rôznych aktivít
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +104,Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0}
+DocType: Item,Inspection Required,Kontrola je povinná
 DocType: Purchase Invoice Item,PR Detail,PR Detail
 DocType: Sales Order,Fully Billed,Plně Fakturovaný
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Pokladní hotovost
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +120,Delivery warehouse required for stock item {0},Dodávka sklad potrebný pre živočíšnu položku {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +123,Delivery warehouse required for stock item {0},Dodávka sklad potrebný pre živočíšnu položku {0}
 DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Celková hmotnost balení. Obvykle se čistá hmotnost + obalového materiálu hmotnosti. (Pro tisk)
 DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Uživatelé s touto rolí se mohou nastavit na zmrazené účty a vytvořit / upravit účetní zápisy proti zmrazených účtů
 DocType: Serial No,Is Cancelled,Je zrušené
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +328,My Shipments,Moje dodávky
 DocType: Journal Entry,Bill Date,Bill Datum
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +43,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","I když existuje více pravidla pro tvorbu cen s nejvyšší prioritou, pak následující interní priority jsou použity:"
 DocType: Sales Invoice Item,Total Margin,celková marža
@@ -2498,25 +2315,22 @@
 DocType: Expense Claim,Approval Status,Stav schválení
 DocType: Hub Settings,Publish Items to Hub,Publikování položky do Hub
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +44,From value must be less than to value in row {0},Z hodnota musí být menší než hodnota v řadě {0}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +133,Wire Transfer,Bankovní převod
-apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py +25,Please select Bank Account,"Prosím, vyberte bankový účet"
-DocType: Newsletter,Create and Send Newsletters,Vytvoření a odeslání Zpravodaje
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +140,Wire Transfer,Bankovní převod
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +131,Check all,"skontrolujte, či všetky"
 DocType: Sales Order,Recurring Order,Opakující se objednávky
 DocType: Company,Default Income Account,Účet Default příjmů
 apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +33,Customer Group / Customer,Zákazník Group / Customer
 DocType: Payment Gateway Account,Default Payment Request Message,Východzí Platba Request Message
 DocType: Item Group,Check this if you want to show in website,"Zaškrtněte, pokud chcete zobrazit v webové stránky"
-apps/erpnext/erpnext/config/accounts.py +126,Banking and Payments,Bankovníctvo a platby
+apps/erpnext/erpnext/config/accounts.py +130,Banking and Payments,Bankovníctvo a platby
 ,Welcome to ERPNext,Vitajte v ERPNext
-DocType: Payment Reconciliation Payment,Voucher Detail Number,Voucher Detail Počet
-apps/erpnext/erpnext/config/crm.py +146,Lead to Quotation,Obchodná iniciatíva na Ponuku
+apps/erpnext/erpnext/config/learn.py +107,Lead to Quotation,Obchodná iniciatíva na Ponuku
 DocType: Lead,From Customer,Od Zákazníka
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +37,Calls,Volá
+apps/erpnext/erpnext/demo/setup_data.py +344,Calls,Volá
 DocType: Project,Total Costing Amount (via Time Logs),Celková kalkulácie Čiastka (cez Time Záznamy)
 DocType: Purchase Order Item Supplied,Stock UOM,Skladová MJ
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána
-apps/erpnext/erpnext/stock/doctype/item/item.js +32,Projected,Plánovaná
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +217,Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána
+apps/erpnext/erpnext/stock/doctype/item/item.js +33,Projected,Plánovaná
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,Serial No {0} does not belong to Warehouse {1},Pořadové číslo {0} nepatří do skladu {1}
 apps/erpnext/erpnext/controllers/status_updater.py +139,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Poznámka: Systém nebude kontrolovat přes dobírku a over-rezervace pro item {0} jako množství nebo částka je 0
 DocType: Notification Control,Quotation Message,Správa k ponuke
@@ -2525,87 +2339,77 @@
 DocType: Purchase Receipt Item,Rate and Amount,Sadzba a množstvo
 apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Listy a Holiday
 DocType: Sales Order,Not Billed,Nevyúčtované
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +115,Both Warehouse must belong to same Company,Oba Sklady musí patřit do stejné společnosti
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +144,Both Warehouse must belong to same Company,Oba Sklady musí patřit do stejné společnosti
 apps/erpnext/erpnext/public/js/templates/contact_list.html +31,No contacts added yet.,Žádné kontakty přidán dosud.
-DocType: Purchase Receipt Item,Landed Cost Voucher Amount,Přistál Náklady Voucher Částka
-DocType: Time Log,Batched for Billing,Zarazeno pro fakturaci
+DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Přistál Náklady Voucher Částka
 apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Směnky vznesené dodavately
-DocType: POS Profile,Write Off Account,Odepsat účet
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1353,Write Off Account,Odepsat účet
 apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Částka slevy
 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/accounts/report/cash_flow/cash_flow.py +16,Net Cash from Operations,Čistý peňažný tok z prevádzkovej
-apps/erpnext/erpnext/public/js/setup_wizard.js +199,e.g. VAT,napríklad DPH
-apps/erpnext/erpnext/config/hr.py +18,Mark Employee Attendance in Bulk,Účasť zamestnancov Mark hromadnú
+apps/erpnext/erpnext/public/js/setup_wizard.js +225,e.g. VAT,napríklad DPH
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Bod 4
 DocType: Journal Entry Account,Journal Entry Account,Zápis do deníku Účet
 DocType: Shopping Cart Settings,Quotation Series,Číselná rada ponúk
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +53,"An item exists with same name ({0}), please change the item group name or rename the item","Položka existuje se stejným názvem ({0}), prosím, změnit název skupiny položky nebo přejmenovat položku"
+apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +59,"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: Company,Asset Depreciation Cost Center,Asset Odpisy nákladového strediska
 DocType: Sales Order Item,Sales Order Date,Prodejní objednávky Datum
 DocType: Sales Invoice Item,Delivered Qty,Dodává Množství
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +266,Purchase Date of asset {0} does not match with Purchase Invoice date,Dátum nákupu aktíva {0} nezhoduje s dátumom nákupnej faktúry
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +71,Warehouse {0}: Company is mandatory,Sklad {0}: Společnost je povinná
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +86,Warehouse {0}: Company is mandatory,Sklad {0}: Společnost je povinná
 ,Payment Period Based On Invoice Date,Platební období na základě data vystavení faktury
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +50,Missing Currency Exchange Rates for {0},Chybí Směnárna Kurzy pro {0}
 DocType: Journal Entry,Stock Entry,Reklamní Entry
 DocType: Account,Payable,Splatný
-apps/erpnext/erpnext/shopping_cart/cart.py +330,Debtors ({0}),Dlžníci ({0})
+apps/erpnext/erpnext/shopping_cart/cart.py +347,Debtors ({0}),Dlžníci ({0})
 DocType: Pricing Rule,Margin,Marže
 DocType: Salary Slip,Arrear Amount,Nedoplatek Částka
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Noví zákazníci
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Gross Profit %,Hrubý Zisk %
 DocType: Appraisal Goal,Weightage (%),Weightage (%)
 DocType: Bank Reconciliation Detail,Clearance Date,Výprodej Datum
-DocType: Newsletter,Newsletter List,Zoznam Newsletterov
-DocType: Process Payroll,Check if you want to send salary slip in mail to each employee while submitting salary slip,"Zkontrolujte, zda chcete poslat výplatní pásku za poštou na každého zaměstnance při předkládání výplatní pásku"
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +40,Gross Purchase Amount is mandatory,Gross Suma nákupu je povinná
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +60,Gross Purchase Amount is mandatory,Gross Suma nákupu je povinná
 DocType: Lead,Address Desc,Popis adresy
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +33,Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena
 apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny."
-DocType: Stock Entry Detail,Source Warehouse,Zdroj Warehouse
+DocType: Asset Movement,Source Warehouse,Zdroj Warehouse
 DocType: Installation Note,Installation Date,Datum instalace
-apps/erpnext/erpnext/controllers/accounts_controller.py +469,Row #{0}: Asset {1} does not belong to company {2},Riadok # {0}: {1} Asset nepatrí do spoločnosti {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +534,Row #{0}: Asset {1} does not belong to company {2},Riadok # {0}: {1} Asset nepatrí do spoločnosti {2}
 DocType: Employee,Confirmation Date,Potvrzení Datum
 DocType: C-Form,Total Invoiced Amount,Celková fakturovaná čiastka
 DocType: Account,Sales User,Uživatel prodeje
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,Min Qty can not be greater than Max Qty,Min množství nemůže být větší než Max Množství
 DocType: Account,Accumulated Depreciation,oprávky
 DocType: Stock Entry,Customer or Supplier Details,Zákazníka alebo dodávateľa Podrobnosti
-DocType: Payment Request,Email To,E-mail na
 DocType: Lead,Lead Owner,Získateľ Obchodnej iniciatívy
 DocType: Bin,Requested Quantity,požadované množstvo
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +256,Warehouse is required,Je potrebná Warehouse
 DocType: Employee,Marital Status,Rodinný stav
 DocType: Stock Settings,Auto Material Request,Auto materiálu Poptávka
-DocType: Time Log,Will be updated when billed.,Bude aktualizována při účtovány.
 DocType: Delivery Note Item,Available Batch Qty at From Warehouse,K dispozícii dávky Množstvo na Od Warehouse
 apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +25,Current BOM and New BOM can not be same,Aktuální BOM a New BOM nemůže být stejné
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date Of Retirement must be greater than Date of Joining,"Datum odchodu do důchodu, musí být větší než Datum spojování"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +111,Date Of Retirement must be greater than Date of Joining,"Datum odchodu do důchodu, musí být větší než Datum spojování"
 DocType: Sales Invoice,Against Income Account,Proti účet příjmů
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +84,{0}% Delivered,{0}% dodané
+apps/erpnext/erpnext/controllers/website_list_for_contact.py +87,{0}% Delivered,{0}% dodané
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +79,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množstvo {1} nemôže byť nižšia ako minimálna Objednané množstvo {2} (definovanej v bode).
 DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Měsíční Distribution Procento
 DocType: Territory,Territory Targets,Území Cíle
 DocType: Delivery Note,Transporter Info,Transporter Info
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +25,Same supplier has been entered multiple times,Rovnaký dodávateľ bol zadaný viackrát
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +29,Same supplier has been entered multiple times,Rovnaký dodávateľ bol zadaný viackrát
 DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Dodané položky vydané objednávky
-apps/erpnext/erpnext/public/js/setup_wizard.js +60,Company Name cannot be Company,Názov spoločnosti nemôže byť Company
+apps/erpnext/erpnext/public/js/setup_wizard.js +83,Company Name cannot be Company,Názov spoločnosti nemôže byť Company
 apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Dopis hlavy na tiskových šablon.
 apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,"Tituly na tiskových šablon, např zálohové faktury."
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +140,Valuation type charges can not marked as Inclusive,Poplatky typu ocenenie môže nie je označený ako Inclusive
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +156,Valuation type charges can not marked as Inclusive,Poplatky typu ocenenie môže nie je označený ako Inclusive
 DocType: POS Profile,Update Stock,Aktualizace skladem
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,"Různé UOM položky povede k nesprávné (celkem) Čistá hmotnost hodnoty. Ujistěte se, že čistá hmotnost každé položky je ve stejném nerozpuštěných."
-DocType: Payment Request,Payment Details,Platobné údaje
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Rate
 DocType: Asset,Journal Entry for Scrap,Zápis do denníka do šrotu
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list"
-apps/erpnext/erpnext/accounts/utils.py +270,Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený
-apps/erpnext/erpnext/config/crm.py +73,"Record of all communications of type email, phone, chat, visit, etc.","Záznam všetkých oznámení typu e-mail, telefón, chát, návštevy, atď"
+apps/erpnext/erpnext/accounts/utils.py +349,Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený
+apps/erpnext/erpnext/config/crm.py +74,"Record of all communications of type email, phone, chat, visit, etc.","Záznam všetkých oznámení typu e-mail, telefón, chát, návštevy, atď"
 DocType: Manufacturer,Manufacturers used in Items,Výrobcovia používané v bodoch
 apps/erpnext/erpnext/accounts/general_ledger.py +140,Please mention Round Off Cost Center in Company,"Prosím, uveďte zaokrúhliť nákladové stredisko v spoločnosti"
 DocType: Purchase Invoice,Terms,Podmínky
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +250,Create New,Vytvořit nový
 DocType: Buying Settings,Purchase Order Required,Vydaná objednávka je vyžadována
 ,Item-wise Sales History,Item-moudrý Sales History
 DocType: Expense Claim,Total Sanctioned Amount,Celková částka potrestána
@@ -2613,152 +2417,138 @@
 DocType: Sales Invoice Item,Delivery Note Item,Delivery Note Item
 DocType: Expense Claim,Task,Úkol
 DocType: Purchase Taxes and Charges,Reference Row #,Referenční Row #
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,Batch number is mandatory for Item {0},Číslo šarže je povinné pro položku {0}
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +14,This is a root sales person and cannot be edited.,To je kořen prodejní člověk a nelze upravovat.
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +79,Batch number is mandatory for Item {0},Číslo šarže je povinné pro položku {0}
+apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,To je kořen prodejní člověk a nelze upravovat.
 ,Stock Ledger,Reklamní Ledger
-apps/erpnext/erpnext/templates/pages/order.html +67,Rate: {0},Sadzba: {0}
+apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Sadzba: {0}
 DocType: Salary Slip Deduction,Salary Slip Deduction,Plat Slip Odpočet
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +201,Select a group node first.,Vyberte první uzel skupinu.
 apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Zamestnancov a dochádzky
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +73,Purpose must be one of {0},Cíl musí být jedním z {0}
-apps/erpnext/erpnext/utilities/doctype/address/address.py +78,"Remove reference of customer, supplier, sales partner and lead, as it is your company address","Odobrať odkaz na zákazníka, dodávateľa, predajné partner a olovo, tak ako je vaša firma adresa"
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +121,Fill the form and save it,Vyplňte formulář a uložte jej
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +72,Purpose must be one of {0},Cíl musí být jedním z {0}
+apps/erpnext/erpnext/utilities/doctype/address/address.py +79,"Remove reference of customer, supplier, sales partner and lead, as it is your company address","Odobrať odkaz na zákazníka, dodávateľa, predajné partner a olovo, tak ako je vaša firma adresa"
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +111,Fill the form and save it,Vyplňte formulář a uložte jej
 DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,"Stáhněte si zprávu, která obsahuje všechny suroviny s jejich aktuální stav zásob"
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum Community
+apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Navštívte komunitné fórum
 DocType: Leave Application,Leave Balance Before Application,Nechte zůstatek před aplikací
 DocType: SMS Center,Send SMS,Pošlete SMS
 DocType: Company,Default Letter Head,Výchozí hlavičkový
 DocType: Purchase Order,Get Items from Open Material Requests,Získať predmety z žiadostí Otvoriť Materiál
-DocType: Time Log,Billable,Zúčtovatelná
+DocType: Timesheet Detail,Billable,Zúčtovatelná
 DocType: Account,Rate at which this tax is applied,"Rychlost, při které se používá tato daň"
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reorder Qty,Změna pořadí Množství
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,Current Job Openings,Aktuálne pracovné príležitosti
+apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +19,Reorder Qty,Změna pořadí Množství
+apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +29,Current Job Openings,Aktuálne pracovné príležitosti
 DocType: Company,Stock Adjustment Account,Reklamní Nastavení účtu
 DocType: Journal Entry,Write Off,Odpísať
-DocType: Time Log,Operation ID,Prevádzka ID
+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/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Z {1}
 DocType: Task,depends_on,záleží na
-DocType: Features Setup,"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Sleva Pole bude k dispozici v objednávce, doklad o koupi, nákupní faktury"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +210,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Názov nového účtu. Poznámka: Prosím, vytvárať účty pre zákazníkov a dodávateľmi"
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +24,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Názov nového účtu. Poznámka: Prosím, vytvárať účty pre zákazníkov a dodávateľmi"
 DocType: BOM Replace Tool,BOM Replace Tool,BOM Nahradit Tool
 apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Země moudrý výchozí adresa Templates
 DocType: Sales Order Item,Supplier delivers to Customer,Dodávateľ doručí zákazníkovi
 apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Položka / {0}) nie je na sklade
 apps/erpnext/erpnext/controllers/recurring_document.py +174,Next Date must be greater than Posting Date,Ďalšie Dátum musí byť väčšia ako Dátum zverejnenia
-apps/erpnext/erpnext/public/js/controllers/transaction.js +777,Show tax break-up,Show daň break-up
-apps/erpnext/erpnext/accounts/party.py +289,Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
+apps/erpnext/erpnext/public/js/controllers/transaction.js +850,Show tax break-up,Show daň break-up
+apps/erpnext/erpnext/accounts/party.py +308,Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
 apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Import dát a export
-DocType: Features Setup,If you involve in manufacturing activity. Enables Item 'Is Manufactured',"Pokud se zapojit do výrobní činnosti. Umožňuje Položka ""se vyrábí"""
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +54,Invoice Posting Date,Faktúra Dátum zverejnenia
+apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Faktúra Dátum zverejnenia
 DocType: Sales Invoice,Rounded Total,Zaoblený Total
 DocType: Product Bundle,List items that form the package.,"Seznam položek, které tvoří balíček."
 apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Podíl alokace by měla být ve výši 100%
 DocType: Serial No,Out of AMC,Out of AMC
-DocType: Purchase Order Item,Material Request Detail No,Materiál Poptávka Detail No
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +33,Make Maintenance Visit,Proveďte návštěv údržby
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +187,Please contact to the user who have Sales Master Manager {0} role,"Prosím, kontaktujte pro uživatele, kteří mají obchodní manažer ve skupině Master {0} roli"
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +35,Make Maintenance Visit,Proveďte návštěv údržby
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +162,Please contact to the user who have Sales Master Manager {0} role,"Prosím, kontaktujte pro uživatele, kteří mají obchodní manažer ve skupině Master {0} roli"
 DocType: Company,Default Cash Account,Výchozí Peněžní účet
-apps/erpnext/erpnext/config/accounts.py +45,Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +101,Please enter 'Expected Delivery Date',"Prosím, zadejte ""Očekávaná Datum dodání"""
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +181,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dodací listy {0} musí být zrušena před zrušením této prodejní objednávky
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +372,Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +80,{0} is not a valid Batch Number for Item {1},{0} nie je platné číslo Šarže pre Položku {1}
+apps/erpnext/erpnext/config/accounts.py +50,Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +104,Please enter 'Expected Delivery Date',"Prosím, zadejte ""Očekávaná Datum dodání"""
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +184,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dodací listy {0} musí být zrušena před zrušením této prodejní objednávky
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +75,Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,{0} is not a valid Batch Number for Item {1},{0} nie je platné číslo Šarže pre Položku {1}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +128,Note: There is not enough leave balance for Leave Type {0},Poznámka: Není k dispozici dostatek zůstatek dovolené dovolená za kalendářní typ {0}
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +9,"Note: If payment is not made against any reference, make Journal Entry manually.","Poznámka: Není-li platba provedena proti jakémukoli rozhodnutí, jak položka deníku ručně."
 DocType: Item,Supplier Items,Dodavatele položky
 DocType: Opportunity,Opportunity Type,Typ Příležitosti
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +42,New Company,Nová spoločnost
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Nová spoločnost
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +57,Cost Center is required for 'Profit and Loss' account {0},"Nákladové středisko je vyžadováno pro účet ""výkaz zisku a ztrát"" {0}"
 apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Transakcie môžu byť vymazané len tvorca Spoločnosti
 apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nesprávný počet hlavní knihy záznamů nalezen. Pravděpodobně jste zvolili nesprávný účet v transakci.
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +31,To create a Bank Account,Chcete-li vytvořit si účet v bance
 DocType: Hub Settings,Publish Availability,Publikování Dostupnost
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +109,Date of Birth cannot be greater than today.,Dátum narodenia nemôže byť väčšia ako dnes.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +105,Date of Birth cannot be greater than today.,Dátum narodenia nemôže byť väčšia ako dnes.
 ,Stock Ageing,Reklamní Stárnutí
-apps/erpnext/erpnext/controllers/accounts_controller.py +219,{0} '{1}' is disabled,{0} '{1}' je vypnuté
+apps/erpnext/erpnext/controllers/accounts_controller.py +228,{0} '{1}' is disabled,{0} '{1}' je vypnuté
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Nastaviť ako Otvorené
 DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Posílat automatické e-maily na Kontakty na předložení transakcí.
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +229,"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
-					Available Qty: {4}, Transfer Qty: {5}","Row {0}: Množství nejsou dostupné iv skladu {1} na {2} {3}.
- Dispozici Množství: {4}, transfer Množství: {5}"
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Položka 3
 DocType: Purchase Order,Customer Contact Email,Zákazník Kontaktný e-mail
 DocType: Warranty Claim,Item and Warranty Details,Položka a Záruka Podrobnosti
 DocType: Sales Team,Contribution (%),Příspěvek (%)
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +473,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Položka Platba nebude vytvořili, protože ""v hotovosti nebo bankovním účtu"" nebyl zadán"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +171,Responsibilities,Zodpovednosť
-apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Template,Šablona
+apps/erpnext/erpnext/controllers/accounts_controller.py +75,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Položka Platba nebude vytvořili, protože ""v hotovosti nebo bankovním účtu"" nebyl zadán"
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +180,Responsibilities,Zodpovednosť
+apps/erpnext/erpnext/stock/doctype/item/item_list.js +14,Template,Šablona
 DocType: Sales Person,Sales Person Name,Prodej Osoba Name
 apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Zadejte prosím aspoň 1 fakturu v tabulce
-apps/erpnext/erpnext/public/js/setup_wizard.js +161,Add Users,Pridať používateľa
+apps/erpnext/erpnext/public/js/setup_wizard.js +184,Add Users,Pridať používateľa
 DocType: Pricing Rule,Item Group,Položka Group
-DocType: Task,Actual Start Date (via Time Logs),Skutočný dátum Start (cez Time Záznamy)
 DocType: Stock Reconciliation Item,Before reconciliation,Pred zmierenie
-apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Chcete-li {0}
+apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Chcete-li {0}
 DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Daně a poplatky Přidal (Company měna)
-apps/erpnext/erpnext/stock/doctype/item/item.py +383,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Položka Tax Row {0} musí mít účet typu daní či výnosů nebo nákladů, nebo Vyměřovací"
+apps/erpnext/erpnext/stock/doctype/item/item.py +439,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Položka Tax Row {0} musí mít účet typu daní či výnosů nebo nákladů, nebo Vyměřovací"
 DocType: Sales Order,Partly Billed,Částečně Účtovaný
 DocType: Item,Default BOM,Výchozí BOM
 apps/erpnext/erpnext/setup/doctype/company/company.js +44,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 +64,Total Outstanding Amt,Celkem Vynikající Amt
-DocType: Time Log Batch,Total Hours,Celkem hodin
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.html +1,Total Outstanding Amt,Celkem Vynikající Amt
+DocType: Timesheet,Total Hours,Celkem hodin
 DocType: Journal Entry,Printing Settings,Nastavenie tlače
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +265,Total Debit must be equal to Total Credit. The difference is {0},Celkové inkaso musí rovnat do celkového kreditu. Rozdíl je {0}
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +11,Automotive,Automobilový
 DocType: Asset Category Account,Fixed Asset Account,Fixed Asset Account
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +50,From Delivery Note,Z Dodacího Listu
-DocType: Time Log,From Time,Času od
+DocType: Timesheet Detail,From Time,Času od
 DocType: Notification Control,Custom Message,Custom Message
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +33,Investment Banking,Investiční bankovnictví
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368,Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +71,Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního
 DocType: Purchase Invoice,Price List Exchange Rate,Katalogová cena Exchange Rate
 DocType: Purchase Invoice Item,Rate,Sadzba
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Intern,Internovat
-DocType: Newsletter,A Lead with this email id should exist,Obchodná iniciatíva s touto emailovou adresou by už mala existovať
 DocType: Stock Entry,From BOM,Od BOM
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +34,Basic,Základní
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +96,Stock transactions before {0} are frozen,Fotky transakce před {0} jsou zmrazeny
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +208,Please click on 'Generate Schedule',"Prosím, klikněte na ""Generovat Schedule"""
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +97,Stock transactions before {0} are frozen,Fotky transakce před {0} jsou zmrazeny
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +217,Please click on 'Generate Schedule',"Prosím, klikněte na ""Generovat Schedule"""
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +63,To Date should be same as From Date for Half Day leave,Chcete-li data by měla být stejná jako u Datum od půl dne volno
-apps/erpnext/erpnext/config/stock.py +186,"e.g. Kg, Unit, Nos, m","napríklad Kg, ks, m"
+apps/erpnext/erpnext/config/stock.py +185,"e.g. Kg, Unit, Nos, m","napríklad Kg, ks, m"
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +95,Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni"
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Joining must be greater than Date of Birth,Datum přistoupení musí být větší než Datum narození
-apps/erpnext/erpnext/hr/doctype/employee/employee.js +29,Salary Structure,Plat struktura
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +108,Date of Joining must be greater than Date of Birth,Datum přistoupení musí být větší než Datum narození
+DocType: Salary Slip,Salary Structure,Plat struktura
 DocType: Account,Bank,Banka
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +9,Airline,Letecká linka
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +615,Issue Material,Vydání Material
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +699,Issue Material,Vydání Material
 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,Citácie
 DocType: Hub Settings,Access Token,Přístupový Token
-DocType: Sales Invoice Item,Serial No,Výrobní číslo
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +135,Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti"
+DocType: Purchase Invoice Item,Serial No,Výrobní číslo
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +144,Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti"
 DocType: Purchase Invoice,Print Language,tlač Language
 DocType: Stock Entry,Including items for sub assemblies,Vrátane položiek pre montážnych podskupín
-DocType: Features Setup,"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Máte-li dlouhé formáty tisku, tato funkce může být použita k rozdělení stránku se bude tisknout na více stránek se všemi záhlaví a zápatí na každé straně"
-DocType: Asset,Number of Depreciations,počet Odpisy
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +98,All Territories,Všechny území
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +98,All Territories,Všetky územia
 DocType: Purchase Invoice,Items,Položky
 DocType: Fiscal Year,Year Name,Meno roku
 DocType: Process Payroll,Process Payroll,Proces Payroll
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +77,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 +144,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
 DocType: Product Bundle Item,Product Bundle Item,Product Bundle Item
 DocType: Sales Partner,Sales Partner Name,Sales Partner Name
-apps/erpnext/erpnext/hooks.py +86,Request for Quotations,Žiadosť o citátov
+apps/erpnext/erpnext/hooks.py +96,Request for Quotations,Žiadosť o citátov
 DocType: Payment Reconciliation,Maximum Invoice Amount,Maximálna suma faktúry
-DocType: Purchase Invoice Item,Image View,Image View
-apps/erpnext/erpnext/config/selling.py +23,Customers,zákazníci
+apps/erpnext/erpnext/config/selling.py +23,Customers,Zákazníci
 DocType: Asset,Partially Depreciated,čiastočne odpíše
 DocType: Issue,Opening Time,Otevírací doba
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Data OD a DO jsou vyžadována
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +46,Securities & Commodity Exchanges,Cenné papíry a komoditních burzách
-apps/erpnext/erpnext/stock/doctype/item/item.py +545,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Východzí merná jednotka varianty &#39;{0}&#39; musí byť rovnaký ako v Template &#39;{1}&#39;
-DocType: Shipping Rule,Calculate Based On,Vypočítat založené na
+apps/erpnext/erpnext/stock/doctype/item/item.py +625,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Východzí merná jednotka varianty &#39;{0}&#39; musí byť rovnaký ako v Template &#39;{1}&#39;
+DocType: Shipping Rule,Calculate Based On,Vypočítať na základe
 DocType: Delivery Note Item,From Warehouse,Zo skladu
 DocType: Purchase Taxes and Charges,Valuation and Total,Oceňování a Total
 DocType: Tax Rule,Shipping City,Prepravné City
-apps/erpnext/erpnext/stock/doctype/item/item.js +59,This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,"Tento bod je varianta {0} (šablony). Atributy budou zkopírovány z šablony, pokud je nastaveno ""No Copy"""
+apps/erpnext/erpnext/stock/doctype/item/item.js +62,This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,"Tento bod je varianta {0} (šablony). Atributy budou zkopírovány z šablony, pokud je nastaveno ""No Copy"""
 DocType: Account,Purchase User,Nákup Uživatel
 DocType: Notification Control,Customize the Notification,Přizpůsobit oznámení
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +17,Cash Flow from Operations,Cash flow z prevádzkových činností
@@ -2766,304 +2556,276 @@
 DocType: Sales Invoice,Shipping Rule,Přepravní Pravidlo
 DocType: Manufacturer,Limited to 12 characters,Obmedzené na 12 znakov
 DocType: Journal Entry,Print Heading,Tisk záhlaví
-DocType: Quotation,Maintenance Manager,Správce údržby
+DocType: Maintenance Schedule,Maintenance Manager,Správca údržby
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +54,Total cannot be zero,Celkem nemůže být nula
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,"""Dní od poslednej objednávky"" musí byť väčšie alebo rovnajúce sa nule"
 DocType: Asset,Amended From,Platném znění
-apps/erpnext/erpnext/public/js/setup_wizard.js +269,Raw Material,Surovina
+apps/erpnext/erpnext/public/js/setup_wizard.js +295,Raw Material,Surovina
 DocType: Leave Application,Follow via Email,Sledovat e-mailem
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po slevě Částka
-apps/erpnext/erpnext/accounts/doctype/account/account.py +195,Child account exists for this account. You can not delete this account.,Dětské konto existuje pro tento účet. Nemůžete smazat tento účet.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +204,Child account exists for this account. You can not delete this account.,Dětské konto existuje pro tento účet. Nemůžete smazat tento účet.
 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á
-apps/erpnext/erpnext/stock/get_item_details.py +484,No default BOM exists for Item {0},No default BOM existuje pro bod {0}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +325,Please select Posting Date first,"Prosím, vyberte najprv Dátum zverejnenia"
+apps/erpnext/erpnext/stock/get_item_details.py +485,No default BOM exists for Item {0},No default BOM existuje pro bod {0}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +336,Please select Posting Date first,"Prosím, vyberte najprv Dátum zverejnenia"
 apps/erpnext/erpnext/public/js/account_tree_grid.js +211,Opening Date should be before Closing Date,Dátum začatia by mala byť pred uzávierky
 DocType: Leave Control Panel,Carry Forward,Převádět
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +54,Cost Center with existing transactions can not be converted to ledger,Nákladové středisko se stávajícími transakcemi nelze převést na hlavní účetní knihy
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Nákladové středisko se stávajícími transakcemi nelze převést na hlavní účetní knihy
 DocType: Department,Days for which Holidays are blocked for this department.,"Dnů, po které Prázdniny jsou blokovány pro toto oddělení."
 ,Produced,Produkoval
 DocType: Item,Item Code for Suppliers,Položka Kód pre dodávateľa
 DocType: Issue,Raised By (Email),Vznesené (e-mail)
-apps/erpnext/erpnext/setup/setup_wizard/default_website.py +72,General,Všeobecný
-apps/erpnext/erpnext/public/js/setup_wizard.js +143,Attach Letterhead,Pripojiť Hlavičku
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +272,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, pokud kategorie je určena pro ""ocenění"" nebo ""oceňování a celkový"""
-apps/erpnext/erpnext/public/js/setup_wizard.js +191,"List your tax heads (e.g. VAT, Customs etc; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Vypíšte vaše používané dane (napr DPH, Clo atď; mali by mať jedinečné názvy) a ich štandardné sadzby. Týmto sa vytvorí štandardná šablóna, ktorú môžete upraviť a pridať ďalšie neskôr."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +460,Please mention 'Gain/Loss Account on Asset Disposal' in Company,Uveďte &#39;/ STRATY zisk z aktív odstraňovaním &quot;vo firme
+DocType: Mode of Payment,General,Všeobecný
+apps/erpnext/erpnext/public/js/setup_wizard.js +166,Attach Letterhead,Pripojiť Hlavičku
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +296,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, pokud kategorie je určena pro ""ocenění"" nebo ""oceňování a celkový"""
+apps/erpnext/erpnext/public/js/setup_wizard.js +217,"List your tax heads (e.g. VAT, Customs etc; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Vypíšte vaše používané dane (napr DPH, Clo atď; mali by mať jedinečné názvy) a ich štandardné sadzby. Týmto sa vytvorí štandardná šablóna, ktorú môžete upraviť a pridať ďalšie neskôr."
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +230,Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
-apps/erpnext/erpnext/config/accounts.py +141,Match Payments with Invoices,Zápas platby faktúrami
+apps/erpnext/erpnext/config/accounts.py +140,Match Payments with Invoices,Zápas platby faktúrami
 DocType: Journal Entry,Bank Entry,Bank Entry
 DocType: Authorization Rule,Applicable To (Designation),Vztahující se na (označení)
-apps/erpnext/erpnext/templates/generators/item.html +68,Add to Cart,Přidat do košíku
+apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Přidat do košíku
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Seskupit podle
-apps/erpnext/erpnext/config/accounts.py +243,Enable / disable currencies.,Povolit / zakázat měny.
+apps/erpnext/erpnext/config/accounts.py +256,Enable / disable currencies.,Povolit / zakázat měny.
 DocType: Production Planning Tool,Get Material Request,Získať Materiál Request
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Postal Expenses,Poštovní náklady
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Postal Expenses,Poštovní náklady
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Total (Amt)
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,Entertainment & Leisure
 DocType: Quality Inspection,Item Serial No,Položka Výrobní číslo
-apps/erpnext/erpnext/controllers/status_updater.py +145,{0} must be reduced by {1} or you should increase overflow tolerance,{0} musí byť znížený o {1} alebo by ste mali zvýšiť toleranciu presahu
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Present,Celkem Present
-apps/erpnext/erpnext/config/accounts.py +97,Accounting Statements,účtovná závierka
-apps/erpnext/erpnext/public/js/setup_wizard.js +273,Hour,Hodina
+apps/erpnext/erpnext/config/accounts.py +101,Accounting Statements,účtovná závierka
+apps/erpnext/erpnext/public/js/setup_wizard.js +299,Hour,Hodina
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +145,"Serialized Item {0} cannot be updated \
 					using Stock Reconciliation","Serialized Položka {0} nelze aktualizovat \
  pomocí Reklamní Odsouhlasení"
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,"New Pořadové číslo nemůže mít Warehouse. Warehouse musí být nastaveny Stock vstupním nebo doklad o koupi,"
 DocType: Lead,Lead Type,Lead Type
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +112,You are not authorized to approve leaves on Block Dates,Nie ste oprávnení schvaľovať lístie na bloku Termíny
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +353,All these items have already been invoiced,Všechny tyto položky již byly fakturovány
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +362,All these items have already been invoiced,Všechny tyto položky již byly fakturovány
 apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Může být schválena {0}
 DocType: Shipping Rule,Shipping Rule Conditions,Přepravní Článek Podmínky
 DocType: BOM Replace Tool,The new BOM after replacement,Nový BOM po výměně
-DocType: Features Setup,Point of Sale,Místo Prodeje
+apps/erpnext/erpnext/accounts/page/pos/pos.js +631,Point of Sale,Místo Prodeje
 DocType: Account,Tax,Daň
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +37,Row {0}: {1} is not a valid {2},Řádek {0}: {1} není platný {2}
 DocType: Production Planning Tool,Production Planning Tool,Plánování výroby Tool
 DocType: Quality Inspection,Report Date,Datum Reportu
 DocType: C-Form,Invoices,Faktúry
 DocType: Job Opening,Job Title,Název pozice
-DocType: Features Setup,Item Groups in Details,Položka skupiny v detailech
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +348,Quantity to Manufacture must be greater than 0.,"Množstvo, ktoré má výroba musí byť väčšia ako 0 ° C."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +4,Start Point-of-Sale (POS),Start Point-of-Sale (POS)
-apps/erpnext/erpnext/config/support.py +32,Visit report for maintenance call.,Navštivte zprávu pro volání údržby.
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +369,Quantity to Manufacture must be greater than 0.,"Množstvo, ktoré má výroba musí byť väčšia ako 0 ° C."
+apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Navštivte zprávu pro volání údržby.
 DocType: Stock Entry,Update Rate and Availability,Obnovovaciu rýchlosť a dostupnosť
 DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,"Procento máte možnost přijímat nebo dodávat více proti objednaného množství. Například: Pokud jste si objednali 100 kusů. a váš příspěvek je 10%, pak máte možnost získat 110 jednotek."
-DocType: Pricing Rule,Customer Group,Zákazník Group
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
+DocType: POS Profile,Customer Group,Zákazník Group
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +185,Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
 DocType: Item,Website Description,Popis webu
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Net Change in Equity,Čistá zmena vo vlastnom imaní
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +94,Please cancel Purchase Invoice {0} first,Zrušte faktúre {0} prvý
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +145,Please cancel Purchase Invoice {0} first,Zrušte faktúre {0} prvý
 DocType: Serial No,AMC Expiry Date,AMC Datum vypršení platnosti
 ,Sales Register,Sales Register
 DocType: Quotation,Quotation Lost Reason,Dôvod neúspešnej ponuky
 DocType: Address,Plant,Rostlina
 apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Není nic upravovat.
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +108,Summary for this month and pending activities,Zhrnutie pre tento mesiac a prebiehajúcim činnostiam
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +107,Summary for this month and pending activities,Zhrnutie pre tento mesiac a prebiehajúcim činnostiam
 DocType: Customer Group,Customer Group Name,Zákazník Group Name
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +409,Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +396,Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1}
 DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Prosím, vyberte převádět pokud chcete také zahrnout uplynulý fiskální rok bilance listy tohoto fiskálního roku"
 DocType: GL Entry,Against Voucher Type,Proti poukazu typu
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +666,Error: {0} &gt; {1},Chyba: {0}&gt; {1}
 DocType: Item,Attributes,Atribúty
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +522,Get Items,Získat položky
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +194,Please enter Write Off Account,"Prosím, zadejte odepsat účet"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Get Items,Získat položky
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +210,Please enter Write Off Account,"Prosím, zadejte odepsat účet"
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Posledná Dátum objednávky
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +39,Account {0} does not belongs to company {1},Účet {0} nie je patria spoločnosti {1}
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +41,Account {0} does not belongs to company {1},Účet {0} nie je patria spoločnosti {1}
 DocType: C-Form,C-Form,C-Form
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +143,Operation ID not set,Prevádzka ID nie je nastavené
 DocType: Payment Request,Initiated,Zahájil
 DocType: Production Order,Planned Start Date,Plánované datum zahájení
 DocType: Serial No,Creation Document Type,Tvorba Typ dokumentu
 DocType: Leave Type,Is Encash,Je inkasovat
 DocType: Purchase Invoice,Mobile No,Mobile No
-DocType: Payment Tool,Make Journal Entry,Proveďte položka deníku
 DocType: Leave Allocation,New Leaves Allocated,Nové Listy Přidělené
 apps/erpnext/erpnext/controllers/trends.py +265,Project-wise data is not available for Quotation,Data dle projektu nejsou k dispozici pro nabídku
 DocType: Project,Expected End Date,Očekávané datum ukončení
 DocType: Appraisal Template,Appraisal Template Title,Posouzení Template Název
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +343,Commercial,Obchodní
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +103,Commercial,Obchodní
 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
-DocType: Cost Center,Distribution Id,Distribuce Id
-apps/erpnext/erpnext/setup/setup_wizard/data/sample_home_page.html +14,Awesome Services,Skvelé služby
-apps/erpnext/erpnext/config/manufacturing.py +52,All Products or Services.,Všechny výrobky nebo služby.
+apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Všechny výrobky nebo služby.
 DocType: Supplier Quotation,Supplier Address,Dodavatel Address
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +505,Row {0}# Account must be of type 'Fixed Asset',Riadok {0} # účet musí byť typu &quot;Fixed Asset&quot;
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +636,Row {0}# Account must be of type 'Fixed Asset',Riadok {0} # účet musí byť typu &quot;Fixed Asset&quot;
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Out Qty,Out Množství
-apps/erpnext/erpnext/config/accounts.py +259,Rules to calculate shipping amount for a sale,Pravidla pro výpočet výše přepravní na prodej
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +29,Series is mandatory,Série je povinné
+apps/erpnext/erpnext/config/accounts.py +272,Rules to calculate shipping amount for a sale,Pravidla pro výpočet výše přepravní na prodej
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +30,Series is mandatory,Série je povinné
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,Finanční služby
-apps/erpnext/erpnext/controllers/item_variant.py +62,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3},Pomer atribút {0} musí byť v rozmedzí od {1} až {2} v krokoch po {3}
 DocType: Tax Rule,Sales,Predaj
 DocType: Stock Entry Detail,Basic Amount,Základná čiastka
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +165,Warehouse required for stock Item {0},Sklad je vyžadován pro skladovou položku {0}
 DocType: Leave Allocation,Unused leaves,Nepoužité listy
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +145,Cr,Cr
-DocType: Customer,Default Receivable Accounts,Výchozí pohledávka účty
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +155,Cr,Cr
 DocType: Tax Rule,Billing State,Fakturácia State
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +640,Transfer,Převod
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +688,Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin)
+apps/erpnext/erpnext/accounts/doctype/asset/asset.js +250,Transfer,Převod
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +772,Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin)
 DocType: Authorization Rule,Applicable To (Employee),Vztahující se na (Employee)
-apps/erpnext/erpnext/controllers/accounts_controller.py +93,Due Date is mandatory,Dátum splatnosti je povinné
-apps/erpnext/erpnext/controllers/item_variant.py +52,Increment for Attribute {0} cannot be 0,Prírastok pre atribút {0} nemôže byť 0
+apps/erpnext/erpnext/controllers/accounts_controller.py +115,Due Date is mandatory,Dátum splatnosti je povinný
+apps/erpnext/erpnext/controllers/item_variant.py +51,Increment for Attribute {0} cannot be 0,Prírastok pre atribút {0} nemôže byť 0
 DocType: Journal Entry,Pay To / Recd From,Platit K / Recd Z
 DocType: Naming Series,Setup Series,Řada Setup
 DocType: Payment Reconciliation,To Invoice Date,Ak chcete dátumu vystavenia faktúry
 DocType: Supplier,Contact HTML,Kontakt HTML
-,Inactive Customers,neaktívne zákazníci
+,Inactive Customers,Neaktívni zákazníci
 DocType: Landed Cost Voucher,Purchase Receipts,Příjmky
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +27,How Pricing Rule is applied?,Jak Ceny pravidlo platí?
 DocType: Quality Inspection,Delivery Note No,Dodacího listu
-DocType: Company,Retail,Maloobchodní
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +106,Customer {0} does not exist,Zákazník {0} neexistuje
+DocType: Company,Retail,Maloobchod
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +118,Customer {0} does not exist,Zákazník {0} neexistuje
 DocType: Attendance,Absent,Nepřítomný
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +439,Product Bundle,Bundle Product
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +534,Product Bundle,Bundle Product
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +185,Row {0}: Invalid reference {1},Riadok {0}: Neplatné referencie {1}
 DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kúpte Dane a poplatky šablóny
 DocType: Upload Attendance,Download Template,Stáhnout šablonu
 DocType: GL Entry,Remarks,Poznámky
 DocType: Purchase Order Item Supplied,Raw Material Item Code,Surovina Kód položky
 DocType: Journal Entry,Write Off Based On,Odepsat založené na
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +602,Send Supplier Emails,Poslať Dodávateľ e-maily
-DocType: Features Setup,POS View,Zobrazení POS
-apps/erpnext/erpnext/config/stock.py +123,Installation record for a Serial No.,Instalace rekord pro sériové číslo
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +689,Send Supplier Emails,Poslať Dodávateľ e-maily
+apps/erpnext/erpnext/config/stock.py +122,Installation record for a Serial No.,Instalace rekord pro sériové číslo
 apps/erpnext/erpnext/controllers/recurring_document.py +187,Next Date's day and Repeat on Day of Month must be equal,deň nasledujúcemu dňu a Opakujte na deň v mesiaci sa musí rovnať
 apps/erpnext/erpnext/public/js/queries.js +39,Please specify a,Uveďte prosím
 DocType: Offer Letter,Awaiting Response,Čaká odpoveď
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +53,Above,Vyššie
-apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +40,Time Log has been Billed,Time Log bol účtovaný
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +187,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Prosím nastavte Pomenovanie Series pre {0} cez Nastavenia&gt; Nastavenia&gt; Pomenovanie Series
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +58,Above,Vyššie
 DocType: Salary Slip,Earning & Deduction,Výdělek a dedukce
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +73,Account {0} cannot be a Group,Účet {0} nemůže být skupina
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +218,Optional. This setting will be used to filter in various transactions.,Volitelné. Toto nastavení bude použito k filtrování v různých transakcí.
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +77,Account {0} cannot be a Group,Účet {0} nemůže být skupina
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +31,Optional. This setting will be used to filter in various transactions.,Volitelné. Toto nastavení bude použito k filtrování v různých transakcí.
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +111,Negative Valuation Rate is not allowed,Negativní ocenění Rate není povoleno
 DocType: Holiday List,Weekly Off,Týdenní Off
 DocType: Fiscal Year,"For e.g. 2012, 2012-13","Pro např 2012, 2012-13"
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit)
+apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +39,Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit)
 DocType: Sales Invoice,Return Against Sales Invoice,Návrat proti predajnej faktúre
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Bod 5
-apps/erpnext/erpnext/accounts/utils.py +278,Please set default value {0} in Company {1},Prosím nastavte výchozí hodnotu {0} ve společnosti {1}
 DocType: Serial No,Creation Time,Čas vytvoření
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Celkový příjem
 DocType: Sales Invoice,Product Bundle Help,Product Bundle Help
 ,Monthly Attendance Sheet,Měsíční Účast Sheet
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +16,No record found,Nebyl nalezen žádný záznam
-apps/erpnext/erpnext/controllers/stock_controller.py +176,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové stredisko je povinné pre položku {2}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +504,Get Items from Product Bundle,Získať predmety z Bundle Product
+apps/erpnext/erpnext/controllers/stock_controller.py +175,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové stredisko je povinné pre položku {2}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +573,Get Items from Product Bundle,Získať predmety z Bundle Product
 DocType: Asset,Straight Line,Priamka
 DocType: Project User,Project User,projekt Užívateľ
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +76,Account {0} is inactive,Účet {0} je neaktivní
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +80,Account {0} is inactive,Účet {0} je neaktivní
 DocType: GL Entry,Is Advance,Je Zálohová
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinná
-apps/erpnext/erpnext/controllers/buying_controller.py +123,Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
+apps/erpnext/erpnext/controllers/buying_controller.py +148,Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
 DocType: Sales Team,Contact No.,Kontakt Číslo
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +64,'Profit and Loss' type account {0} not allowed in Opening Entry,"""Výkaz zisku a straty"" typ účtu {0} nie je privilegovaný pre Sprístupnenie Údajov"
-DocType: Features Setup,Sales Discounts,Prodejní Slevy
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +68,'Profit and Loss' type account {0} not allowed in Opening Entry,"""Výkaz zisku a straty"" typ účtu {0} nie je privilegovaný pre Sprístupnenie Údajov"
 DocType: Hub Settings,Seller Country,Prodejce Country
 apps/erpnext/erpnext/config/learn.py +278,Publish Items on Website,Publikovať položky na webových stránkach
 DocType: Authorization Rule,Authorization Rule,Autorizační pravidlo
 DocType: Sales Invoice,Terms and Conditions Details,Podmínky podrobnosti
-apps/erpnext/erpnext/templates/generators/item.html +83,Specifications,Specifikace
+apps/erpnext/erpnext/templates/generators/item.html +86,Specifications,Specifikace
 DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Predaj Dane a poplatky šablóny
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +10,Apparel & Accessories,Oblečení a doplňky
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Číslo objednávky
 DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, které se zobrazí na první místo v seznamu výrobků."
-DocType: Shipping Rule,Specify conditions to calculate shipping amount,Stanovení podmínek pro vypočítat výši poštovného
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +120,Add Child,Přidat dítě
+DocType: Shipping Rule,Specify conditions to calculate shipping amount,Stanovte podmienky na výpočet výšky prepravných nákladov
 DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit Mražené Příspěvky
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +52,Cannot convert Cost Center to ledger as it has child nodes,"Nelze převést nákladového střediska na knihy, protože má podřízené uzly"
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,"Nelze převést nákladového střediska na knihy, protože má podřízené uzly"
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +47,Opening Value,otvorenie Value
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +37,Serial #,Serial #
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +90,Commission on Sales,Provize z prodeje
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Commission on Sales,Provize z prodeje
 DocType: Offer Letter Term,Value / Description,Hodnota / Popis
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +492,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Riadok # {0}: Asset {1} nemôže byť predložený, je už {2}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +558,"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,Fakturácia Krajina
-,Customers Not Buying Since Long Time,Zákazníci nekupujete Po dlouhou dobu
 DocType: Production Order,Expected Delivery Date,Očekávané datum dodání
 apps/erpnext/erpnext/accounts/general_ledger.py +127,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetné a kreditné nerovná za {0} # {1}. Rozdiel je v tom {2}.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +96,Entertainment Expenses,Výdaje na reprezentaci
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +189,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodejní faktury {0} musí být zrušena před zrušením této prodejní objednávky
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +61,Age,Věk
-DocType: Time Log,Billing Amount,Fakturácia Suma
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +192,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodejní faktury {0} musí být zrušena před zrušením této prodejní objednávky
+apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +60,Age,Věk
+DocType: Sales Invoice Timesheet,Billing Amount,Fakturácia Suma
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Neplatný množství uvedené na položku {0}. Množství by mělo být větší než 0.
 apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Žádosti o dovolenou.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +193,Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Výdaje na právní služby
-DocType: Sales Invoice,Posting Time,Čas zadání
+apps/erpnext/erpnext/accounts/doctype/account/account.py +202,Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +100,Legal Expenses,Výdaje na právní služby
+DocType: Purchase Invoice,Posting Time,Čas zadání
 DocType: Sales Order,% Amount Billed,% Fakturovanej čiastky
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Telephone Expenses,Telefonní Náklady
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +116,Telephone Expenses,Telefonní Náklady
 DocType: Sales Partner,Logo,Logo
 DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Zaškrtněte, pokud chcete, aby uživateli vybrat sérii před uložením. Tam bude žádná výchozí nastavení, pokud jste zkontrolovat."
 apps/erpnext/erpnext/stock/get_item_details.py +117,No Item with Serial No {0},No Položka s Serial č {0}
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +95,Open Notifications,Otvorené Oznámenie
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Direct Expenses,Přímé náklady
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +77,Direct Expenses,Přímé náklady
 apps/erpnext/erpnext/controllers/recurring_document.py +210,"{0} is an invalid email address in 'Notification \
 						Email Address'",{0} je neplatná e-mailová adresa v &quot;Oznámenie \ &#39;e-mailovú adresu
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Nový zákazník Příjmy
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Travel Expenses,Cestovní výdaje
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Travel Expenses,Cestovní výdaje
 DocType: Maintenance Visit,Breakdown,Rozbor
-apps/erpnext/erpnext/controllers/accounts_controller.py +553,Account: {0} with currency: {1} can not be selected,Účet: {0} s menou: {1} nemožno vybrať
+apps/erpnext/erpnext/controllers/accounts_controller.py +634,Account: {0} with currency: {1} can not be selected,Účet: {0} s menou: {1} nemožno vybrať
 DocType: Bank Reconciliation Detail,Cheque Date,Šek Datum
-apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2}
+apps/erpnext/erpnext/accounts/doctype/account/account.py +54,Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2}
 apps/erpnext/erpnext/setup/doctype/company/company.js +60,Successfully deleted all transactions related to this company!,Úspešne vypúšťa všetky transakcie súvisiace s týmto spoločnosti!
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Rovnako ako u Date
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +58,Probation,Zkouška
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +173,Payment of salary for the month {0} and year {1},Platba platu za měsíc {0} a rok {1}
-DocType: Stock Settings,Auto insert Price List rate if missing,"Auto vložka Cenník miera, ak chýba"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Paid Amount,Celkem uhrazené částky
-,Transferred Qty,Přenesená Množství
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +168,Payment of salary for the month {0} and year {1},Platba platu za měsíc {0} a rok {1}
+DocType: Stock Settings,Auto insert Price List rate if missing,Automaticky vložiť cenníkovú cenu ak neexistuje
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.html +1,Total Paid Amount,Celkem uhrazené částky
+DocType: Production Order Item,Transferred Qty,Přenesená Množství
 apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigácia
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +137,Planning,Plánování
-apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +20,Make Time Log Batch,Udělejte si čas Log Batch
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +146,Planning,Plánování
 apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Issued,Vydané
 DocType: Project,Total Billing Amount (via Time Logs),Celkom Billing Suma (cez Time Záznamy)
-apps/erpnext/erpnext/public/js/setup_wizard.js +275,We sell this Item,Táto položka je na predaj
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +65,Supplier Id,Dodavatel Id
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +214,Quantity should be greater than 0,Množstvo by mala byť väčšia ako 0
+apps/erpnext/erpnext/public/js/setup_wizard.js +301,We sell this Item,Táto položka je na predaj
+apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +68,Supplier Id,Dodavatel Id
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +212,Quantity should be greater than 0,Množstvo by mala byť väčšia ako 0
 DocType: Journal Entry,Cash Entry,Cash Entry
 DocType: Sales Partner,Contact Desc,Kontakt Popis
 apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Typ ponechává jako neformální, nevolnosti atd."
 DocType: Email Digest,Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy e-mailem.
-DocType: Brand,Item Manager,Manažér Položka
-DocType: Cost Center,Add rows to set annual budgets on Accounts.,Přidat řádky stanovit roční rozpočty na účtech.
+DocType: Brand,Item Manager,Manažér položiek
 DocType: Buying Settings,Default Supplier Type,Výchozí typ Dodavatel
 DocType: Production Order,Total Operating Cost,Celkové provozní náklady
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +150,Note: Item {0} entered multiple times,Poznámka: Položka {0} vstoupil vícekrát
-apps/erpnext/erpnext/config/crm.py +27,All Contacts.,Všechny kontakty.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +270,Supplier of asset {0} does not match with the supplier in the Purchase Invoice,Dodávateľ aktíva {0} nezhoduje s dodávateľom na faktúre
-DocType: Newsletter,Test Email Id,Testovací Email Id
-apps/erpnext/erpnext/public/js/setup_wizard.js +19,Company Abbreviation,Skratka názvu spoločnosti
-DocType: Features Setup,If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,"Pokud se budete řídit kontroly jakosti. Umožňuje položky QA požadovány, a QA No v dokladu o koupi"
+apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Všechny kontakty.
+apps/erpnext/erpnext/public/js/setup_wizard.js +45,Company Abbreviation,Skratka názvu spoločnosti
 DocType: GL Entry,Party Type,Typ Party
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +80,Raw material cannot be same as main Item,Surovina nemůže být stejný jako hlavní bod
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +78,Raw material cannot be same as main Item,Surovina nemůže být stejný jako hlavní bod
 DocType: Item Attribute Value,Abbreviation,Zkratka
 apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Není authroized od {0} překročí limity
 apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Plat master šablona.
 DocType: Leave Type,Max Days Leave Allowed,Max Days Leave povolena
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +55,Set Tax Rule for shopping cart,Sada Daňové Pravidlo pre nákupného košíka
-DocType: Payment Tool,Set Matching Amounts,Nastaviť Zodpovedajúce Sumy
 DocType: Purchase Invoice,Taxes and Charges Added,Daně a poplatky přidané
 ,Sales Funnel,Prodej Nálevka
-apps/erpnext/erpnext/setup/doctype/company/company.py +41,Abbreviation is mandatory,Skratka je povinné
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +136,Thank you for your interest in subscribing to our updates,Ďakujeme Vám za Váš záujem o prihlásenie do našich aktualizácií
+apps/erpnext/erpnext/setup/doctype/company/company.py +41,Abbreviation is mandatory,Skratka je povinná
 ,Qty to Transfer,Množství pro přenos
 apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Ponuka z Obchodnej Iniciatívy alebo pre Zákazníka
 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/install_fixtures.py +101,All Customer Groups,Všechny skupiny zákazníků
-apps/erpnext/erpnext/controllers/accounts_controller.py +514,{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/accounts/doctype/tax_rule/tax_rule.py +37,Tax Template is mandatory.,Daňová šablóna je povinné.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje
+apps/erpnext/erpnext/controllers/accounts_controller.py +595,{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/accounts/doctype/tax_rule/tax_rule.py +38,Tax Template is mandatory.,Daňová šablóna je povinné.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje
 DocType: Purchase Invoice Item,Price List Rate (Company Currency),Ceník Rate (Company měny)
 DocType: Account,Temporary,Dočasný
 DocType: Address,Preferred Billing Address,Preferovaná Fakturační Adresa
-apps/erpnext/erpnext/accounts/party.py +238,Billing currency must be equal to either default comapany's currency or party's payble account currency,Fakturačná mena sa musí rovnať peňazí buď predvoleného comapany alebo payble meny účtu účastníka
 DocType: Monthly Distribution Percentage,Percentage Allocation,Procento přidělení
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Secretary,Sekretářka
 DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Pokiaľ zakázať, &quot;v slovách&quot; poli nebude viditeľný v akejkoľvek transakcie"
 DocType: Serial No,Distinct unit of an Item,Samostatnou jednotku z položky
 DocType: Pricing Rule,Buying,Nákupy
 DocType: HR Settings,Employee Records to be created by,"Zaměstnanec Záznamy, které vytvořil"
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +24,This Time Log Batch has been cancelled.,To Batch Time Log byla zrušena.
+DocType: POS Profile,Apply Discount On,Použiť Zľava na
 ,Reqd By Date,Pr p Podľa dátumu
 DocType: Salary Slip Earning,Salary Slip Earning,Plat Slip Zisk
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +164,Creditors,Věřitelé
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +94,Row # {0}: Serial No is mandatory,Riadok # {0}: Výrobné číslo je povinné
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Creditors,Věřitelé
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +95,Row # {0}: Serial No is mandatory,Riadok # {0}: Výrobné číslo je povinné
 DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Položka Wise Tax Detail
 ,Item-wise Price List Rate,Item-moudrý Ceník Rate
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +724,Supplier Quotation,Dodávateľská ponuka
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +806,Supplier Quotation,Dodávateľská ponuka
 DocType: Quotation,In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku."
-apps/erpnext/erpnext/stock/doctype/item/item.py +395,Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +451,Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
 DocType: Lead,Add to calendar on this date,Přidat do kalendáře k tomuto datu
-apps/erpnext/erpnext/config/stock.py +97,Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.
+apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +40,Upcoming Events,Pripravované akcie
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Je nutná zákazník
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +27,Quick Entry,Rýchly vstup
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} je povinné pre návrat
 DocType: Purchase Order,To Receive,Obdržať
-apps/erpnext/erpnext/public/js/setup_wizard.js +172,user@example.com,user@example.com
+apps/erpnext/erpnext/public/js/setup_wizard.js +195,user@example.com,user@example.com
 DocType: Email Digest,Income / Expense,Výnosy / náklady
 DocType: Employee,Personal Email,Osobní e-mail
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +62,Total Variance,Celkový rozptyl
+apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Celkový rozptyl
 DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Pokud je povoleno, bude systém odesílat účetní položky k zásobám automaticky."
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +15,Brokerage,Makléřská
 DocType: Address,Postal Code,poštové smerovacie číslo
@@ -3072,18 +2834,17 @@
  aktualizované pomocou ""Time Log"""
 DocType: Customer,From Lead,Od Obchodnej iniciatívy
 apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Objednávky uvolněna pro výrobu.
-apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +42,Select Fiscal Year...,Vyberte fiskálního roku ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +449,POS Profile required to make POS Entry,"POS Profile požadované, aby POS Vstup"
+apps/erpnext/erpnext/public/js/account_tree_grid.js +67,Select Fiscal Year...,Vyberte fiskálního roku ...
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +443,POS Profile required to make POS Entry,"POS Profile požadované, aby POS Vstup"
 DocType: Hub Settings,Name Token,Názov Tokenu
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +106,Standard Selling,Standardní prodejní
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +136,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
+apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standardní prodejní
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +135,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
 DocType: Serial No,Out of Warranty,Out of záruky
 DocType: BOM Replace Tool,Replace,Vyměnit
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +330,{0} against Sales Invoice {1},{0} proti Predajnej Faktúre {1}
 DocType: Request for Quotation Item,Project Name,Název projektu
 DocType: Supplier,Mention if non-standard receivable account,Zmienka v prípade neštandardnej pohľadávky účet
 DocType: Journal Entry Account,If Income or Expense,Pokud je výnos nebo náklad
-DocType: Features Setup,Item Batch Nos,Položka Batch Nos
 DocType: Stock Ledger Entry,Stock Value Difference,Reklamní Value Rozdíl
 apps/erpnext/erpnext/config/learn.py +239,Human Resource,Ľudské Zdroje
 DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Platba Odsouhlasení Platba
@@ -3103,11 +2864,11 @@
 apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiškálny rok: {0} neexistuje
 DocType: Currency Exchange,To Currency,Chcete-li měny
 DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Nechte následující uživatelé schválit Žádost o dovolenou.
-apps/erpnext/erpnext/config/hr.py +136,Types of Expense Claim.,Druhy výdajů nároku.
+apps/erpnext/erpnext/config/hr.py +132,Types of Expense Claim.,Druhy výdajů nároku.
 DocType: Item,Taxes,Daně
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +299,Paid and Not Delivered,Platená a nie je doručenie
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +301,Paid and Not Delivered,Platená a nie je doručenie
 DocType: Project,Default Cost Center,Výchozí Center Náklady
-DocType: Sales Invoice,End Date,Datum ukončení
+DocType: Purchase Invoice,End Date,Datum ukončení
 apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,sklad Transakcia
 DocType: Employee,Internal Work History,Vnitřní práce History
 DocType: Depreciation Schedule,Accumulated Depreciation Amount,oprávky Suma
@@ -3115,33 +2876,32 @@
 DocType: Maintenance Visit,Customer Feedback,Zpětná vazba od zákazníků
 DocType: Account,Expense,Výdaj
 DocType: Sales Invoice,Exhibition,Výstava
-apps/erpnext/erpnext/utilities/doctype/address/address.py +76,"Company is mandatory, as it is your company address","Spoločnosť je povinná, pretože to je vaša firma adresa"
+apps/erpnext/erpnext/utilities/doctype/address/address.py +77,"Company is mandatory, as it is your company address","Spoločnosť je povinná, pretože to je vaša firma adresa"
 DocType: Item Attribute,From Range,Od Rozsah
-apps/erpnext/erpnext/stock/utils.py +89,Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem"
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +30,Submit this Production Order for further processing.,Odeslat tento výrobní zakázka pro další zpracování.
+apps/erpnext/erpnext/stock/utils.py +99,Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +34,Submit this Production Order for further processing.,Odeslat tento výrobní zakázka pro další zpracování.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +21,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","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: Company,Domain,Doména
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +23,Jobs,jobs
+apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Jobs,jobs
 ,Sales Order Trends,Prodejní objednávky Trendy
 DocType: Employee,Held On,Které se konalo dne
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +33,Production Item,Výrobní položka
 ,Employee Information,Informace o zaměstnanci
-apps/erpnext/erpnext/public/js/setup_wizard.js +201,Rate (%),Sadzba (%)
-DocType: Time Log,Additional Cost,Dodatočné náklady
-apps/erpnext/erpnext/public/js/setup_wizard.js +41,Financial Year End Date,Dátum ukončenia finančného roku
+apps/erpnext/erpnext/public/js/setup_wizard.js +227,Rate (%),Sadzba (%)
+DocType: Stock Entry Detail,Additional Cost,Dodatočné náklady
+apps/erpnext/erpnext/public/js/setup_wizard.js +62,Financial Year End Date,Dátum ukončenia finančného roku
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Voucher No, if grouped by Voucher","Nelze filtrovat na základě poukazu ne, pokud seskupeny podle poukazu"
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +599,Make Supplier Quotation,Vytvořit nabídku dodavatele
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +710,Make Supplier Quotation,Vytvoriť ponuku od dodávateľa
 DocType: Quality Inspection,Incoming,Přicházející
 DocType: BOM,Materials Required (Exploded),Potřebný materiál (Rozložený)
 DocType: Salary Structure Earning,Reduce Earning for Leave Without Pay (LWP),Snížit Zisk na vstup bez nároku na mzdu (LWP)
-apps/erpnext/erpnext/public/js/setup_wizard.js +162,"Add users to your organization, other than yourself",Pridanie ďalších používateľov do vašej organizácie okrem Vás
+apps/erpnext/erpnext/public/js/setup_wizard.js +185,"Add users to your organization, other than yourself",Pridanie ďalších používateľov do vašej organizácie okrem Vás
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +100,Row # {0}: Serial No {1} does not match with {2} {3},Riadok # {0}: Výrobné číslo {1} nezodpovedá {2} {3}
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +44,Casual Leave,Casual Leave
 DocType: Batch,Batch ID,Šarže ID
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +350,Note: {0},Poznámka: {0}
 ,Delivery Note Trends,Dodací list Trendy
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +104,This Week's Summary,Tento týždeň Zhrnutie
-apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +74,{0} must be a Purchased or Sub-Contracted Item in row {1},"{0} musí byť Kúpená, alebo Subdodávateľská položka v riadku {1}"
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +103,This Week's Summary,Tento týždeň Zhrnutie
 apps/erpnext/erpnext/accounts/general_ledger.py +106,Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím Skladových Transakcí
 DocType: GL Entry,Party,Strana
 DocType: Sales Order,Delivery Date,Dodávka Datum
@@ -3154,7 +2914,7 @@
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Avg. Buying Rate,Avg. Nákup Rate
 DocType: Task,Actual Time (in Hours),Skutočná doba (v hodinách)
 DocType: Employee,History In Company,Historie ve Společnosti
-apps/erpnext/erpnext/config/crm.py +151,Newsletters,Newslettery
+apps/erpnext/erpnext/config/learn.py +112,Newsletters,Newslettery
 DocType: Address,Shipping,Lodní
 DocType: Stock Ledger Entry,Stock Ledger Entry,Reklamní Ledger Entry
 DocType: Department,Leave Block List,Nechte Block List
@@ -3162,52 +2922,44 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +188,Item {0} is not setup for Serial Nos. Column must be blank,Položka {0} není nastavení pro Serial č. Sloupec musí být prázdný
 DocType: Accounts Settings,Accounts Settings,Nastavenie účtu
 DocType: Customer,Sales Partner and Commission,Predaj Partner a Komisie
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +168,Please set 'Asset Disposal Account' in Company {0},Prosím nastavte dispozícii majetkový účet &quot;vo firme {0}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +53,Plant and Machinery,Továrna a strojní zařízení
-DocType: Sales Partner,Partner's Website,Partnera Website
 DocType: Opportunity,To Discuss,K projednání
 DocType: SMS Settings,SMS Settings,Nastavenie SMS
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +63,Temporary Accounts,Dočasné Účty
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +155,Black,Čierna
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +69,Temporary Accounts,Dočasné Účty
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +164,Black,Čierna
 DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Item
 DocType: Account,Auditor,Auditor
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +10,Return,Spiatočná
 DocType: Production Order Operation,Production Order Operation,Výrobní zakázka Operace
 DocType: Pricing Rule,Disable,Zakázat
 DocType: Project Task,Pending Review,Čeká Review
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +132, Click here to pay,Kliknite tu platiť
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +101,"Asset {0} cannot be scrapped, as it is already {1}","Aktíva {0} nemôže byť vyhodený, ako je to už {1}"
+apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +106,"Asset {0} cannot be scrapped, as it is already {1}","Aktíva {0} nemôže byť vyhodený, ako je to už {1}"
 DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku)
-apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py +66,Customer Id,Zákazník Id
+apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py +69,Customer Id,Zákazník Id
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +176,Mark Absent,mark Absent
-apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +107,To Time must be greater than From Time,Ak chcete čas musí byť väčší ako From Time
 DocType: Journal Entry Account,Exchange Rate,Výmenný kurz
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +483,Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +722,Add items from,Pridať položky z
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +82,Warehouse {0}: Parent account {1} does not bolong to the company {2},Sklad {0}: Nadřazený účet {1} napatří společnosti {2}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +461,Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +804,Add items from,Pridať položky z
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +97,Warehouse {0}: Parent account {1} does not bolong to the company {2},Sklad {0}: Nadřazený účet {1} napatří společnosti {2}
 DocType: BOM,Last Purchase Rate,Last Cena při platbě
 DocType: Account,Asset,Majetek
 DocType: Project Task,Task ID,Task ID
-apps/erpnext/erpnext/public/js/setup_wizard.js +20,"e.g. ""MC""","napríklad ""MC """
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +86,Stock cannot exist for Item {0} since has variants,"Sklad nemůže existovat k bodu {0}, protože má varianty"
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +87,Stock cannot exist for Item {0} since has variants,"Sklad nemůže existovat k bodu {0}, protože má varianty"
 ,Sales Person-wise Transaction Summary,Prodej Person-moudrý Shrnutí transakce
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +112,Warehouse {0} does not exist,Sklad {0} neexistuje
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +141,Warehouse {0} does not exist,Sklad {0} neexistuje
 apps/erpnext/erpnext/hub_node/page/hub/register_in_hub.html +2,Register For ERPNext Hub,Registrace pro ERPNext Hub
 DocType: Monthly Distribution,Monthly Distribution Percentages,Měsíční Distribuční Procenta
 apps/erpnext/erpnext/stock/doctype/batch/batch.py +16,The selected item cannot have Batch,Vybraná položka nemůže mít dávku
 DocType: Delivery Note,% of materials delivered against this Delivery Note,% materiálov dodaných proti tomuto dodaciemu listu
-DocType: Features Setup,Compact Item Print,Kompaktné Položka Print
 DocType: Project,Customer Details,Podrobnosti zákazníků
 DocType: Employee,Reports to,Zprávy
 DocType: SMS Settings,Enter url parameter for receiver nos,Zadejte url parametr pro přijímače nos
-DocType: Sales Invoice,Paid Amount,Uhrazené částky
+DocType: Payment Entry,Paid Amount,Uhrazené částky
 ,Available Stock for Packing Items,K dispozici skladem pro balení položek
 DocType: Item Variant,Item Variant,Variant Položky
-apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +16,Setting this Address Template as default as there is no other default,"Nastavení Tato adresa šablonu jako výchozí, protože není jiná výchozí"
-apps/erpnext/erpnext/accounts/doctype/account/account.py +113,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
+apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +16,Setting this Address Template as default as there is no other default,"Nastavujem túto šablónu adresy ako predvolenú, lebo nie je k dispozícii žiadna predvolená"
+apps/erpnext/erpnext/accounts/doctype/account/account.py +117,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +76,Quality Management,Řízení kvality
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +31,Item {0} has been disabled,Item {0} bol zakázaný
-DocType: Payment Tool Detail,Against Voucher No,Proti poukaz č
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +39,Item {0} has been disabled,Item {0} bol zakázaný
 apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +47,Please enter quantity for Item {0},"Zadejte prosím množství produktů, bod {0}"
 DocType: Employee External Work History,Employee External Work History,Zaměstnanec vnější práce History
 DocType: Tax Rule,Purchase,Nákup
@@ -3218,7 +2970,7 @@
 DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Sazba, za kterou dodavatel měny je převeden na společnosti základní měny"
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: časování v rozporu s řadou {1}
 DocType: Opportunity,Next Contact,Nasledujúci Kontakt
-apps/erpnext/erpnext/config/accounts.py +253,Setup Gateway accounts.,Nastavenia brány účty.
+apps/erpnext/erpnext/config/accounts.py +266,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 +40,Fixed Assets,Dlouhodobý majetek
 ,Cash Flow,Cash Flow
@@ -3227,13 +2979,11 @@
 DocType: Employee,Notice (days),Oznámenie (dni)
 DocType: Tax Rule,Sales Tax Template,Daň z predaja Template
 DocType: Employee,Encashment Date,Inkaso Datum
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +183,"Against Voucher Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Proti poukazu Type musí být jedním z objednávky, faktury nebo Journal Entry"
 DocType: Account,Stock Adjustment,Úprava skladových zásob
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Existuje Náklady Predvolené aktivity pre Typ aktivity - {0}
 DocType: Production Order,Planned Operating Cost,Plánované provozní náklady
-apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +121,New {0} Name,Nový Názov {0}
 apps/erpnext/erpnext/controllers/recurring_document.py +133,Please find attached {0} #{1},V příloze naleznete {0} # {1}
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Bank Statement balance as per General Ledger,Výpis z bankového účtu zostatok podľa hlavnej knihy
+apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Výpis z bankového účtu zostatok podľa hlavnej knihy
 DocType: Job Applicant,Applicant Name,Žadatel Název
 DocType: Authorization Rule,Customer / Item Name,Zákazník / Název zboží
 DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 
@@ -3245,28 +2995,26 @@
 Note: BOM = Bill of Materials","Súhrnný skupina ** položiek ** do iného ** Položka **. To je užitočné, ak sa zväzovanie niektoré položky ** ** do balíka a budete udržiavať zásoby balených ** Položky ** a nie agregát ** položky **. Balíček ** Položka ** bude mať &quot;Je skladom,&quot; ako &quot;Nie&quot; a &quot;Je predaja Item&quot; ako &quot;Yes&quot;. Napríklad: Ak predávate notebooky a batohy oddelene a majú špeciálnu cenu, ak zákazník kúpi obidva, potom Laptop + Backpack bude nový Bundle Product Item. Poznámka: BOM = Nomenklatúra"
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Pořadové číslo je povinná k bodu {0}
 DocType: Item Variant Attribute,Attribute,Atribút
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +21,Please specify from/to range,Uveďte z / do rozmedzie
+apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +36,Please specify from/to range,Uveďte z / do rozmedzie
 DocType: Serial No,Under AMC,Podle AMC
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +47,Item valuation rate is recalculated considering landed cost voucher amount,Bod míra ocenění je přepočítána zvažuje přistál nákladů částku poukazu
-apps/erpnext/erpnext/config/selling.py +147,Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +54,Item valuation rate is recalculated considering landed cost voucher amount,Bod míra ocenění je přepočítána zvažuje přistál nákladů částku poukazu
+apps/erpnext/erpnext/config/selling.py +143,Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.
 DocType: BOM Replace Tool,Current BOM,Aktuální BOM
 apps/erpnext/erpnext/public/js/utils.js +39,Add Serial No,Přidat Sériové číslo
-apps/erpnext/erpnext/config/support.py +43,Warranty,záruka
+apps/erpnext/erpnext/config/support.py +22,Warranty,záruka
 DocType: Production Order,Warehouses,Sklady
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Print and Stationary,Print a Stacionární
-apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +122,Group Node,Group Node
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +92,Update Finished Goods,Dokončení aktualizace zboží
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Print and Stationary,Print a Stacionární
 DocType: Workstation,per hour,za hodinu
 apps/erpnext/erpnext/config/buying.py +7,Purchasing,nákup
 DocType: Warehouse,Account for the warehouse (Perpetual Inventory) will be created under this Account.,"Účet pro skladu (průběžné inventarizace), bude vytvořena v rámci tohoto účtu."
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +103,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse nelze vypustit, neboť existuje zásob, kniha pro tento sklad."
-DocType: Company,Distribution,Distribuce
-apps/erpnext/erpnext/public/js/pos/pos.js +435,Amount Paid,Zaplacené částky
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +119,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse nelze vypustit, neboť existuje zásob, kniha pro tento sklad."
+DocType: Company,Distribution,Distribúcia
+apps/erpnext/erpnext/schools/doctype/fees/fees.js +8,Amount Paid,Zaplacené částky
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +91,Project Manager,Project Manager
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +72,Dispatch,Odeslání
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +70,Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
 DocType: Account,Receivable,Pohledávky
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +262,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Riadok # {0}: Nie je povolené meniť dodávateľa, objednávky už existuje"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +265,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Riadok # {0}: Nie je povolené meniť dodávateľa, objednávky už existuje"
 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."
 DocType: Sales Invoice,Supplier Reference,Dodavatel Označení
 DocType: Production Planning Tool,"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Je-li zaškrtnuto, bude BOM pro sub-montážní položky považují pro získání surovin. V opačném případě budou všechny sub-montážní položky být zacházeno jako surovinu."
@@ -3289,38 +3037,37 @@
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},"Chcete-li data by měla být v rámci fiskálního roku. Za předpokladu, že To Date = {0}"
 DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Zde si můžete udržet výšku, váhu, alergie, zdravotní problémy atd"
 DocType: Leave Block List,Applies to Company,Platí pre firmu
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +179,Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože předložena Reklamní Entry {0} existuje"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +193,Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože předložena Reklamní Entry {0} existuje"
 DocType: Purchase Invoice,In Words,Slovy
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Today is {0}'s birthday!,Dnes je {0} 's narozeniny!
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +224,Today is {0}'s birthday!,Dnes je {0} 's narozeniny!
 DocType: Production Planning Tool,Material Request For Warehouse,Materiál Request For Warehouse
 DocType: Sales Order Item,For Production,Pro Výrobu
 DocType: Payment Request,payment_url,payment_url
 DocType: Project Task,View Task,Zobraziť Task
-apps/erpnext/erpnext/public/js/setup_wizard.js +40,Your financial year begins on,Váš finančný rok začína
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +46,Please enter Purchase Receipts,"Prosím, zadejte Nákup Příjmy"
+apps/erpnext/erpnext/public/js/setup_wizard.js +61,Your financial year begins on,Váš finančný rok začína
 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/stock/doctype/stock_entry/stock_entry.py +427,Transaction not allowed against stopped Production Order {0},Transakce není povoleno proti zastavila výrobu Objednat {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +432,Transaction not allowed against stopped Production Order {0},Transakce není povoleno proti zastavila výrobu Objednat {0}
 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í"""
-apps/erpnext/erpnext/projects/doctype/project/project.py +133,Join,pripojiť
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +19,Shortage Qty,Nedostatek Množství
-apps/erpnext/erpnext/stock/doctype/item/item.py +569,Item variant {0} exists with same attributes,Variant Položky {0} existuje s rovnakými vlastnosťami
+apps/erpnext/erpnext/projects/doctype/project/project.py +141,Join,pripojiť
+apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Nedostatek Množství
+apps/erpnext/erpnext/stock/doctype/item/item.py +649,Item variant {0} exists with same attributes,Variant Položky {0} existuje s rovnakými vlastnosťami
 DocType: Salary Slip,Salary Slip,Plat Slip
 DocType: Pricing Rule,Margin Rate or Amount,Margin sadzbou alebo pevnou sumou
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +48,'To Date' is required,"""Datum Do"" je povinný"
+apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +48,'To Date' is required,"""Dátum Do"" je povinný"
 DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generování balení pásky pro obaly mají být dodány. Používá se k oznámit číslo balíku, obsah balení a jeho hmotnost."
 DocType: Sales Invoice Item,Sales Order Item,Prodejní objednávky Item
 DocType: Salary Slip,Payment Days,Platební dny
 DocType: BOM,Manage cost of operations,Správa nákladů na provoz
-DocType: Features Setup,Item Advanced,Položka Advanced
 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."
 apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globálne nastavenia
 DocType: Employee Education,Employee Education,Vzdělávání zaměstnanců
-apps/erpnext/erpnext/public/js/controllers/transaction.js +793,It is needed to fetch Item Details.,"Je potrebné, aby priniesla Detaily položky."
+apps/erpnext/erpnext/public/js/controllers/transaction.js +866,It is needed to fetch Item Details.,"Je potrebné, aby priniesla Detaily položky."
 DocType: Salary Slip,Net Pay,Net Pay
 DocType: Account,Account,Účet
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} has already been received,Pořadové číslo {0} již obdržel
 ,Requested Items To Be Transferred,Požadované položky mají být převedeny
+DocType: Purchase Invoice,Recurring Id,Opakující se Id
 DocType: Customer,Sales Team Details,Podrobnosti prodejní tým
 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.
@@ -3329,34 +3076,32 @@
 DocType: Email Digest,Email Digest,Email Digest
 DocType: Delivery Note,Billing Address Name,Jméno Fakturační adresy
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +22,Department Stores,Obchodní domy
-apps/erpnext/erpnext/controllers/stock_controller.py +72,No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady
-apps/erpnext/erpnext/projects/doctype/project/project.js +73,Save the document first.,Uložte dokument ako prvý.
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +313,No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady
+apps/erpnext/erpnext/projects/doctype/project/project.js +96,Save the document first.,Uložte dokument ako prvý.
 DocType: Account,Chargeable,Vyměřovací
 DocType: Company,Change Abbreviation,Zmeniť skratku
 DocType: Expense Claim Detail,Expense Date,Datum výdaje
 DocType: Item,Max Discount (%),Max sleva (%)
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Poslední částka objednávky
-DocType: Company,Warn,Varovat
+DocType: Budget,Warn,Varovat
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Akékoľvek iné poznámky, pozoruhodné úsilie, ktoré by mali ísť v záznamoch."
 DocType: BOM,Manufacturing User,Výroba Uživatel
-DocType: Purchase Order,Raw Materials Supplied,Dodává suroviny
+DocType: Purchase Invoice,Raw Materials Supplied,Dodává suroviny
 DocType: Purchase Invoice,Recurring Print Format,Opakujúce Print Format
 DocType: C-Form,Series,Série
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +55,Expected Delivery Date cannot be before Purchase Order Date,"Očekávané datum dodání, nemůže být před zakoupením pořadí Datum"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +58,Expected Delivery Date cannot be before Purchase Order Date,"Očekávané datum dodání, nemůže být před zakoupením pořadí Datum"
 DocType: Appraisal,Appraisal Template,Posouzení Template
 DocType: Item Group,Item Classification,Položka Klasifikace
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +89,Business Development Manager,Business Development Manager
 DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Maintenance Visit Účel
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +15,Period,Období
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +12,General Ledger,Hlavná Účtovná Kniha
+apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +16,Period,Období
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Hlavná Účtovná Kniha
 apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Zobraziť Obchodné iniciatívy
 DocType: Item Attribute Value,Attribute Value,Hodnota atributu
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +67,"Email id must be unique, already exists for {0}","E-mail id musí být jedinečný, již existuje {0}"
+apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +42,"Email id must be unique, already exists for {0}","E-mail id musí být jedinečný, již existuje {0}"
 ,Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +268,Please select {0} first,"Prosím, nejprve vyberte {0}"
-DocType: Features Setup,To get Item Group in details table,Chcete-li získat položku Group v tabulce Rozpis
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +114,Batch {0} of Item {1} has expired.,Batch {0} z {1} bodu vypršala.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Please set a default Holiday List for Employee {0} or Company {0},Prosím nastaviť predvolené Holiday List pre zamestnancov {0} alebo spoločnosti {0}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +643,Please select {0} first,"Prosím, nejprve vyberte {0}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +749,Batch {0} of Item {1} has expired.,Batch {0} z {1} bodu vypršala.
 DocType: Sales Invoice,Commission,Provize
 DocType: Address Template,"<h4>Default Template</h4>
 <p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p>
@@ -3381,145 +3126,131 @@
  {% v případě, fax%} Fax: {{fax}} & lt; br & gt; {% endif -%} 
  {%, pokud email_id%} E-mail: {{email_id}} & lt; br & gt ; {% endif -%} 
  </ code> </ pre>"
-DocType: Salary Slip Deduction,Default Amount,Výchozí částka
+DocType: Salary Detail,Default Amount,Výchozí částka
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +96,Warehouse not found in the system,Sklad nebyl nalezen v systému
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +107,This Month's Summary,Tento mesiac je zhrnutie
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +106,This Month's Summary,Tento mesiac je zhrnutie
 DocType: Quality Inspection Reading,Quality Inspection Reading,Kvalita Kontrola Reading
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,`Zmraziť zásoby staršie ako` malo by byť menšie než %d dní.
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +24,`Freeze Stocks Older Than` should be smaller than %d days.,`Zmraziť zásoby staršie ako` malo by byť menšie než %d dní.
 DocType: Tax Rule,Purchase Tax Template,Spotrebná daň šablóny
 ,Project wise Stock Tracking,Sledování zboží dle projektu
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +157,Maintenance Schedule {0} exists against {0},Plán údržby {0} existuje na {0}
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +166,Maintenance Schedule {0} exists against {0},Plán údržby {0} existuje na {0}
 DocType: Stock Entry Detail,Actual Qty (at source/target),Skutečné množství (u zdroje/cíle)
 DocType: Item Customer Detail,Ref Code,Ref Code
 apps/erpnext/erpnext/config/hr.py +12,Employee records.,Zaměstnanecké záznamy.
 DocType: Payment Gateway,Payment Gateway,Platobná brána
 DocType: HR Settings,Payroll Settings,Nastavení Mzdové
-apps/erpnext/erpnext/config/accounts.py +143,Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
-apps/erpnext/erpnext/templates/pages/cart.html +22,Place Order,Objednať
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +25,Root cannot have a parent cost center,Root nemůže mít rodič nákladové středisko
-apps/erpnext/erpnext/public/js/stock_analytics.js +59,Select Brand...,Select Brand ...
+apps/erpnext/erpnext/config/accounts.py +142,Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
+apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Objednať
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Root nemůže mít rodič nákladové středisko
+apps/erpnext/erpnext/public/js/stock_analytics.js +58,Select Brand...,Select Brand ...
 DocType: Sales Invoice,C-Form Applicable,C-Form Použitelné
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +353,Operation Time must be greater than 0 for Operation {0},Prevádzková doba musí byť väčšia ako 0 pre prevádzku {0}
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +104,Warehouse is mandatory,Sklad je povinné
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +374,Operation Time must be greater than 0 for Operation {0},Prevádzková doba musí byť väčšia ako 0 pre prevádzku {0}
+apps/erpnext/erpnext/accounts/doctype/account/account.py +170,Warehouse is mandatory,Sklad je povinné
 DocType: Supplier,Address and Contacts,Adresa a kontakty
 DocType: UOM Conversion Detail,UOM Conversion Detail,Detail konverzie MJ
-apps/erpnext/erpnext/public/js/setup_wizard.js +144,Keep it web friendly 900px (w) by 100px (h),Snažte sa o rozmer vhodný na web: 900px šírka a 100px výška
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +342,Production Order cannot be raised against a Item Template,Výrobná zákazka nemôže byť vznesená proti šablóny položky
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +44,Charges are updated in Purchase Receipt against each item,Poplatky jsou aktualizovány v dokladu o koupi na každou položku
-DocType: Payment Tool,Get Outstanding Vouchers,Získejte Vynikající poukazy
+apps/erpnext/erpnext/public/js/setup_wizard.js +167,Keep it web friendly 900px (w) by 100px (h),Snažte sa o rozmer vhodný na web: 900px šírka a 100px výška
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +363,Production Order cannot be raised against a Item Template,Výrobná zákazka nemôže byť vznesená proti šablóny položky
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +51,Charges are updated in Purchase Receipt against each item,Poplatky jsou aktualizovány v dokladu o koupi na každou položku
 DocType: Warranty Claim,Resolved By,Vyřešena
 DocType: Appraisal,Start Date,Datum zahájení
 apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Přidělit listy dobu.
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +50,Cheques and Deposits incorrectly cleared,Šeky a Vklady nesprávne vymazané
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +139,Click here to verify,Kliknite tu pre overenie
-apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Účet {0}: nelze přiřadit sebe jako nadřazený účet
+apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Šeky a Vklady nesprávne vymazané
+apps/erpnext/erpnext/accounts/doctype/account/account.py +50,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,Ceník Rate
 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ť
-DocType: Time Log,Hours,Hodiny
+apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Hodiny
 DocType: Project,Expected Start Date,Očekávané datum zahájení
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +41,Remove item if charges is not applicable to that item,Odebrat pokud poplatků není pro tuto položku
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +48,Remove item if charges is not applicable to that item,Odebrat pokud poplatků není pro tuto položku
 DocType: SMS Settings,Eg. smsgateway.com/api/send_sms.cgi,Např. smsgateway.com/api/send-sms.cgi
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Transaction currency must be same as Payment Gateway currency,Mena transakcie musí byť rovnaká ako platobná brána menu
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +636,Receive,Príjem
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +27,Transaction currency must be same as Payment Gateway currency,Mena transakcie musí byť rovnaká ako platobná brána menu
+DocType: Payment Entry,Receive,Príjem
 DocType: Maintenance Visit,Fully Completed,Plně Dokončeno
 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
 DocType: Purchase Invoice,Submit on creation,Predloženie návrhu na vytvorenie
 DocType: Employee Leave Approver,Employee Leave Approver,Zaměstnanec Leave schvalovač
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +166,{0} has been successfully added to our Newsletter list.,{0} bol úspešne pridaný do nášho zoznamu noviniek.
-apps/erpnext/erpnext/stock/doctype/item/item.py +425,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Položka Změna pořadí již pro tento sklad existuje {1}
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +65,"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
+apps/erpnext/erpnext/stock/doctype/item/item.py +490,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Položka Změna pořadí již pro tento sklad existuje {1}
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +77,"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
 DocType: Purchase Taxes and Charges Template,Purchase Master Manager,Nákup Hlavní manažer
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +424,Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +141,Please select Start Date and End Date for Item {0},"Prosím, vyberte Počáteční datum a koncové datum pro položku {0}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +429,Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +150,Please select Start Date and End Date for Item {0},"Prosím, vyberte Počáteční datum a koncové datum pro položku {0}"
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,K dnešnímu dni nemůže být dříve od data
-DocType: Purchase Receipt Item,Prevdoc DocType,Prevdoc DOCTYPE
-apps/erpnext/erpnext/stock/doctype/item/item.js +174,Add / Edit Prices,Pridať / Upraviť ceny
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +53,Chart of Cost Centers,Diagram nákladových středisek
+DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DOCTYPE
+apps/erpnext/erpnext/stock/doctype/item/item.js +217,Add / Edit Prices,Pridať / Upraviť ceny
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +35,Chart of Cost Centers,Diagram nákladových středisek
 ,Requested Items To Be Ordered,Požadované položky je třeba objednat
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +313,My Orders,Moje objednávky
 DocType: Price List,Price List Name,Názov cenníku
-DocType: Time Log,For Manufacturing,Pre výrobu
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +174,Totals,Súčty
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +178,Totals,Súčty
 DocType: BOM,Manufacturing,Výroba
 ,Ordered Items To Be Delivered,"Objednané zboží, které mají být dodány"
 DocType: Account,Income,Příjem
 DocType: Industry Type,Industry Type,Typ Průmyslu
-apps/erpnext/erpnext/templates/includes/cart.js +136,Something went wrong!,Něco se pokazilo!
+apps/erpnext/erpnext/templates/includes/cart.js +141,Something went wrong!,Něco se pokazilo!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +103,Warning: Leave application contains following block dates,Upozornění: Nechte Aplikace obsahuje následující data bloku
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +241,Sales Invoice {0} has already been submitted,Prodejní faktury {0} již byla odeslána
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +245,Sales Invoice {0} has already been submitted,Prodejní faktury {0} již byla odeslána
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Fiškálny rok {0} neexistuje
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Dokončení Datum
 DocType: Purchase Invoice Item,Amount (Company Currency),Částka (Měna Společnosti)
-apps/erpnext/erpnext/config/hr.py +185,Organization unit (department) master.,Organizace jednotka (departement) master.
+apps/erpnext/erpnext/config/hr.py +181,Organization unit (department) master.,Organizace jednotka (departement) master.
 apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +25,Please enter valid mobile nos,Zadejte platné mobilní nos
-DocType: Budget Detail,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"
-apps/erpnext/erpnext/config/accounts.py +258,Point-of-Sale Profile,Point-of-Sale Profil
+apps/erpnext/erpnext/config/accounts.py +271,Point-of-Sale Profile,Point-of-Sale Profil
 apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +68,Please Update SMS Settings,Aktualizujte prosím nastavení SMS
-apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +37,Time Log {0} already billed,Time Log {0} už účtoval
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +179,Unsecured Loans,Nezajištěných úvěrů
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +153,Unsecured Loans,Nezajištěných úvěrů
 DocType: Cost Center,Cost Center Name,Meno nákladového strediska
 DocType: Maintenance Schedule Detail,Scheduled Date,Plánované datum
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +63,Total Paid Amt,Celkem uhrazeno Amt
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.html +1,Total Paid Amt,Celkem uhrazeno Amt
 DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Zprávy větší než 160 znaků bude rozdělena do více zpráv
 DocType: Purchase Receipt Item,Received and Accepted,Přijaté a Přijato
 ,Serial No Service Contract Expiry,Pořadové číslo Servisní smlouva vypršení platnosti
 DocType: Item,Unit of Measure Conversion,Jednotka miery konverzie
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +86,Employee can not be changed,Zaměstnanec nemůže být změněn
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +87,Employee can not be changed,Zaměstnanec nemůže být změněn
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +272,You cannot credit and debit same account at the same time,Nemůžete dělat kreditní a debetní záznam na stejný účet ve stejnou dobu.
 DocType: Naming Series,Help HTML,Nápoveda HTML
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +50,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/controllers/status_updater.py +143,Allowance for over-{0} crossed for Item {1},Příspěvek na nadměrné {0} přešel k bodu {1}
 DocType: Address,Name of person or organization that this address belongs to.,"Meno osoby alebo organizácie, ktorej patrí táto adresa."
-apps/erpnext/erpnext/public/js/setup_wizard.js +234,Your Suppliers,Vaši Dodávatelia
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +53,Cannot set as Lost as Sales Order is made.,"Nelze nastavit jako Ztraceno, protože je přijata objednávka."
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +65,Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,"Další platovou strukturu {0} je aktivní pro zaměstnance {1}. Prosím, aby jeho stav ""neaktivní"" pokračovat."
-apps/erpnext/erpnext/templates/includes/rfq/rfq_macros.html +16,Supplier Part No,Žiadny dodávateľ Part
-DocType: Purchase Invoice,Contact,Kontakt
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +9,Received From,Prijaté Od
-DocType: Features Setup,Exports,Vývoz
+apps/erpnext/erpnext/public/js/setup_wizard.js +260,Your Suppliers,Vaši Dodávatelia
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +49,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/payment_entry/payment_entry.py +319,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í
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +15,{0}: From {0} for {1},{0}: Od {0} do {1}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +150,Row #{0}: Set Supplier for item {1},Riadok # {0}: Nastavte Dodávateľ pre položku {1}
-apps/erpnext/erpnext/stock/doctype/item/item.py +119,Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} pripája k bodu {1} nemožno nájsť
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +153,Row #{0}: Set Supplier for item {1},Riadok # {0}: Nastavte Dodávateľ pre položku {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +168,Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} pripája k bodu {1} nemožno nájsť
 DocType: Issue,Content Type,Typ obsahu
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,Počítač
 DocType: Item,List this Item in multiple groups on the website.,Seznam tuto položku ve více skupinách na internetových stránkách.
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +296,Please check Multi Currency option to allow accounts with other currency,"Prosím, skontrolujte viac mien možnosť povoliť účty s inú menu"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +74,Item: {0} does not exist in the system,Položka: {0} neexistuje v systému
-apps/erpnext/erpnext/accounts/doctype/account/account.py +105,You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +72,Item: {0} does not exist in the system,Položka: {0} neexistuje v systému
+apps/erpnext/erpnext/accounts/doctype/account/account.py +109,You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení
 DocType: Payment Reconciliation,Get Unreconciled Entries,Získat smířit záznamů
 DocType: Payment Reconciliation,From Invoice Date,Z faktúry Dátum
-DocType: Cost Center,Budgets,Rozpočty
-apps/erpnext/erpnext/public/js/setup_wizard.js +21,What does it do?,Čím sa zaoberá?
+apps/erpnext/erpnext/public/js/setup_wizard.js +48,What does it do?,Čím sa zaoberá?
 DocType: Delivery Note,To Warehouse,Do skladu
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +45,Account {0} has been entered more than once for fiscal year {1},Účet {0} byl zadán více než jednou za fiskální rok {1}
 ,Average Commission Rate,Průměrná cena Komise
-apps/erpnext/erpnext/stock/doctype/item/item.py +356,'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemôže byť ""áno"" pre neskladový tovar"
+apps/erpnext/erpnext/stock/doctype/item/item.py +412,'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemôže byť ""áno"" pre neskladový tovar"
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +34,Attendance can not be marked for future dates,Účast nemůže být označen pro budoucí data
 DocType: Pricing Rule,Pricing Rule Help,Ceny Pravidlo Help
 DocType: Purchase Taxes and Charges,Account Head,Účet Head
-apps/erpnext/erpnext/config/stock.py +164,Update additional costs to calculate landed cost of items,Aktualizace dodatečné náklady pro výpočet vyložené náklady položek
+apps/erpnext/erpnext/config/stock.py +163,Update additional costs to calculate landed cost of items,Aktualizace dodatečné náklady pro výpočet vyložené náklady položek
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +111,Electrical,Elektrický
 DocType: Stock Entry,Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In)
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +318,Row {0}: Exchange Rate is mandatory,Riadok {0}: Exchange Rate je povinné
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},User ID není nastavena pro zaměstnance {0}
 DocType: Stock Entry,Default Source Warehouse,Výchozí zdroj Warehouse
 DocType: Item,Customer Code,Code zákazníků
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +219,Birthday Reminder for {0},Narozeninová připomínka pro {0}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +223,Birthday Reminder for {0},Narozeninová připomínka pro {0}
 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 +306,Debit To account must be a Balance Sheet account,Debetné Na účet musí byť účtu Súvaha
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +293,Debit To account must be a Balance Sheet account,Debetné Na účet musí byť účtu Súvaha
 DocType: Buying Settings,Naming Series,Číselné rady
 DocType: Leave Block List,Leave Block List Name,Nechte Jméno Block List
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Stock Aktiva
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +29,Do you really want to Submit all Salary Slip for month {0} and year {1},"Opravdu chcete, aby předložila všechny výplatní pásce za měsíc {0} a rok {1}"
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +8,Import Subscribers,Importovať Odberatelia
 DocType: Target Detail,Target Qty,Target Množství
 DocType: Shopping Cart Settings,Checkout Settings,pokladňa Nastavenie
 DocType: Attendance,Present,Současnost
@@ -3528,7 +3259,7 @@
 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
 DocType: Authorization Rule,Based On,Založeno na
 DocType: Sales Order Item,Ordered Qty,Objednáno Množství
-apps/erpnext/erpnext/stock/doctype/item/item.py +585,Item {0} is disabled,Položka {0} je zakázaná
+apps/erpnext/erpnext/stock/doctype/item/item.py +670,Item {0} is disabled,Položka {0} je zakázaná
 DocType: Stock Settings,Stock Frozen Upto,Reklamní Frozen aľ
 apps/erpnext/erpnext/controllers/recurring_document.py +169,Period From and Period To dates mandatory for recurring {0},"Obdobie od a obdobia, k dátam povinné pre opakované {0}"
 apps/erpnext/erpnext/config/projects.py +18,Project activity / task.,Projektová činnost / úkol.
@@ -3536,14 +3267,12 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Buying must be checked, if Applicable For is selected as {0}","Nákup musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Sleva musí být menší než 100
 DocType: Purchase Invoice,Write Off Amount (Company Currency),Odpísať Suma (Company meny)
-apps/erpnext/erpnext/stock/doctype/item/item.py +417,Row #{0}: Please set reorder quantity,Riadok # {0}: Prosím nastavte množstvo objednávacie
+apps/erpnext/erpnext/stock/doctype/item/item.py +482,Row #{0}: Please set reorder quantity,Riadok # {0}: Prosím nastavte množstvo objednávacie
 DocType: Landed Cost Voucher,Landed Cost Voucher,Přistálo Náklady Voucher
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +55,Please set {0},Prosím nastavte {0}
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +53,Please set {0},Prosím nastavte {0}
 DocType: Purchase Invoice,Repeat on Day of Month,Opakujte na den v měsíci
 DocType: Employee,Health Details,Zdravotní Podrobnosti
 DocType: Offer Letter,Offer Letter Terms,Ponuka Letter Podmienky
-DocType: Features Setup,To track any installation or commissioning related work after sales,Chcete-li sledovat jakékoli zařízení nebo uvedení do provozu souvisejících s prací po prodeji
-DocType: Purchase Invoice Advance,Journal Entry Detail No,Zápis do deníku Detail No
 DocType: Employee External Work History,Salary,Plat
 DocType: Serial No,Delivery Document Type,Dodávka Typ dokumentu
 DocType: Process Payroll,Submit all salary slips for the above selected criteria,Odeslat všechny výplatní pásky pro výše zvolených kritérií
@@ -3553,43 +3282,42 @@
 DocType: Email Digest,Receivables,Pohledávky
 DocType: Customer,Additional information regarding the customer.,Ďalšie informácie týkajúce sa zákazníka.
 DocType: Quality Inspection Reading,Reading 5,Čtení 5
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +37,Campaign Name is required,Je zapotřebí Název kampaně
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +38,Campaign Name is required,Je zapotřebí Název kampaně
 DocType: Maintenance Visit,Maintenance Date,Datum údržby
-DocType: Purchase Receipt Item,Rejected Serial No,Zamítnuto Serial No
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +73,Year start date or end date is overlapping with {0}. To avoid please set company,Rok dátum začatia alebo ukončenia sa prekrýva s {0}. Aby sa zabránilo nastavte firmu
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +40,New Newsletter,New Newsletter
-apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +148,Start date should be less than end date for Item {0},Datum zahájení by měla být menší než konečné datum pro bod {0}
+DocType: Purchase Invoice Item,Rejected Serial No,Zamítnuto Serial No
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +80,Year start date or end date is overlapping with {0}. To avoid please set company,Rok dátum začatia alebo ukončenia sa prekrýva s {0}. Aby sa zabránilo nastavte firmu
+apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +157,Start date should be less than end date for Item {0},Datum zahájení by měla být menší než konečné datum pro bod {0}
 DocType: Item,"Example: ABCD.#####
 If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Příklad:. ABCD ##### 
  Je-li série nastavuje a pořadové číslo není uvedeno v transakcích, bude vytvořen poté automaticky sériové číslo na základě této série. Pokud chcete vždy výslovně uvést pořadová čísla pro tuto položku. ponechte prázdné."
 DocType: Upload Attendance,Upload Attendance,Nahráť Dochádzku
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +119,BOM and Manufacturing Quantity are required,BOM a výroba množstva sú povinné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +129,BOM and Manufacturing Quantity are required,BOM a výroba množstva sú povinné
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Stárnutí rozsah 2
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +451,Amount,Částka
+DocType: Bank Reconciliation Detail,Amount,Částka
 apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +21,BOM replaced,BOM nahradil
 ,Sales Analytics,Prodejní Analytics
 DocType: Manufacturing Settings,Manufacturing Settings,Nastavenia Výroby
 apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Nastavenia pre e-mail
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +92,Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +96,Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr
 DocType: Stock Entry Detail,Stock Entry Detail,Reklamní Entry Detail
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +101,Daily Reminders,Denná Upomienky
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +82,Tax Rule Conflicts with {0},Daňové Pravidlo Konflikty s {0}
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +209,New Account Name,Nový názov účtu
+apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +100,Daily Reminders,Denná Upomienky
+DocType: Products Settings,Home Page is Products,Domovskou stránkou je stránka Produkty.
+apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +85,Tax Rule Conflicts with {0},Daňové Pravidlo Konflikty s {0}
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +23,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
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +73,Customer Service,Služby zákazníkům
-DocType: Item,Thumbnail,Thumbnail
+DocType: Homepage Featured Product,Thumbnail,Thumbnail
 DocType: Item Customer Detail,Item Customer Detail,Položka Detail Zákazník
-apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +147,Confirm Your Email,Potvrdiť Váš e-mail
 apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Ponuka kandidát Job.
 DocType: Notification Control,Prompt for Email on Submission of,Výzva pro e-mail na předkládání
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +81,Total allocated leaves are more than days in the period,Celkové pridelené listy sú viac ako dní v období
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +83,Total allocated leaves are more than days in the period,Celkové pridelené listy sú viac ako dní v období
 DocType: Pricing Rule,Percentage,percento
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +72,Item {0} must be a stock Item,Položka {0} musí být skladem
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +73,Item {0} must be a stock Item,Položka {0} musí být skladem
 DocType: Manufacturing Settings,Default Work In Progress Warehouse,Východiskové prácu v sklade Progress
-apps/erpnext/erpnext/config/accounts.py +233,Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
+apps/erpnext/erpnext/config/accounts.py +246,Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +59,Expected Date cannot be before Material Request Date,Očekávané datum nemůže být před Materiál Poptávka Datum
-apps/erpnext/erpnext/stock/get_item_details.py +131,Item {0} must be a Sales Item,Bod {0} musí být prodejní položky
+apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Chyba: Nie je platný id?
 DocType: Naming Series,Update Series Number,Aktualizace Series Number
 DocType: Account,Equity,Hodnota majetku
 DocType: Sales Order,Printing Details,Tlač detailov
@@ -3597,17 +3325,17 @@
 DocType: Sales Order Item,Produced Quantity,Produkoval Množství
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Engineer,Inženýr
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Vyhľadávanie Sub Assemblies
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +378,Item Code required at Row No {0},Kód položky třeba na řádku č {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365,Item Code required at Row No {0},Kód položky třeba na řádku č {0}
 DocType: Sales Partner,Partner Type,Partner Type
 DocType: Purchase Taxes and Charges,Actual,Aktuální
 DocType: Authorization Rule,Customerwise Discount,Sleva podle zákazníka
 DocType: Purchase Invoice,Against Expense Account,Proti výdajového účtu
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +36,"Go to the appropriate group (usually Source of Funds &gt; Current Liabilities &gt; Taxes and Duties and create a new Account (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.",Prejdite do príslušnej skupiny (zvyčajne zdrojom finančných prostriedkov&gt; krátkodobých záväzkov&gt; daní a poplatkov a vytvoriť nový účet (kliknutím na Pridať podriadenej) typu &quot;dane&quot; a to nehovorím o sadzbu dane.
 DocType: Production Order,Production Order,Výrobní Objednávka
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +248,Installation Note {0} has already been submitted,Poznámka k instalaci {0} již byla odeslána
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +252,Installation Note {0} has already been submitted,Poznámka k instalaci {0} již byla odeslána
 DocType: Quotation Item,Against Docname,Proti Docname
 DocType: SMS Center,All Employee (Active),Všichni zaměstnanci (Aktivní)
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Zobrazit nyní
+DocType: Purchase Invoice,Select the period when the invoice will be generated automatically,"Vyberte období, kdy faktura budou generovány automaticky"
 DocType: BOM,Raw Material Cost,Cena surovin
 DocType: Item Reorder,Re-Order Level,Re-Order Level
 DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,"Zadejte položky a plánované ks, pro které chcete získat zakázky na výrobu, nebo stáhnout suroviny pro analýzu."
@@ -3615,68 +3343,62 @@
 DocType: Employee,Applicable Holiday List,Použitelný Seznam Svátků
 DocType: Employee,Cheque,Šek
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +56,Series Updated,Řada Aktualizováno
-apps/erpnext/erpnext/accounts/doctype/account/account.py +158,Report Type is mandatory,Report Type je povinné
+apps/erpnext/erpnext/accounts/doctype/account/account.py +162,Report Type is mandatory,Report Type je povinné
 DocType: Item,Serial Number Series,Sériové číslo Series
 apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +69,Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný pro skladovou položku {0} na řádku {1}
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +45,Retail & Wholesale,Maloobchod a velkoobchod
 DocType: Issue,First Responded On,Prvně odpovězeno dne
 DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Výpis zboží v několika skupinách
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +81,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Datum zahájení a  Datum ukončení Fiskálního roku jsou již stanoveny ve fiskálním roce {0}
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +115,Successfully Reconciled,Úspěšně smířeni
+apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +88,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Datum zahájení a  Datum ukončení Fiskálního roku jsou již stanoveny ve fiskálním roce {0}
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Úspěšně smířeni
 DocType: Production Order,Planned End Date,Plánované datum ukončení
-apps/erpnext/erpnext/config/stock.py +180,Where items are stored.,"Tam, kde jsou uloženy předměty."
+apps/erpnext/erpnext/config/stock.py +179,Where items are stored.,"Tam, kde jsou uloženy předměty."
 DocType: Tax Rule,Validity,Platnosť
 DocType: Request for Quotation,Supplier Detail,dodávateľ Detail
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +19,Invoiced Amount,Fakturovaná čiastka
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.html +1,Invoiced Amount,Fakturovaná čiastka
 DocType: Attendance,Attendance,Účast
-apps/erpnext/erpnext/config/projects.py +55,Reports,správy
 DocType: BOM,Materials,Materiály
 DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Pokud není zatrženo, seznam bude muset být přidány ke každé oddělení, kde má být použit."
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508,Posting date and posting time is mandatory,Datum a čas zadání je povinný
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +513,Posting date and posting time is mandatory,Datum a čas zadání je povinný
 apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Daňové šablona pro nákup transakcí.
 ,Item Prices,Ceny Položek
 DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,"Ve slovech budou viditelné, jakmile uložíte objednávce."
 DocType: Period Closing Voucher,Period Closing Voucher,Období Uzávěrka Voucher
-apps/erpnext/erpnext/config/stock.py +77,Price List master.,Ceník master.
+apps/erpnext/erpnext/config/selling.py +67,Price List master.,Ceník master.
 DocType: Task,Review Date,Review Datum
 DocType: Purchase Invoice,Advance Payments,Zálohové platby
 DocType: Purchase Taxes and Charges,On Net Total,On Net Celkem
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +159,Target warehouse in row {0} must be same as Production Order,Target sklad v řádku {0} musí být stejná jako výrobní zakázky
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +99,No permission to use Payment Tool,Nemáte oprávnění k použití platební nástroj
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +158,Target warehouse in row {0} must be same as Production Order,Target sklad v řádku {0} musí být stejná jako výrobní zakázky
 apps/erpnext/erpnext/controllers/recurring_document.py +214,'Notification Email Addresses' not specified for recurring %s,"""E-mailové adresy pre oznámenie"" nie sú uvedené pre odpovedanie %s"
-apps/erpnext/erpnext/accounts/doctype/account/account.py +123,Currency can not be changed after making entries using some other currency,Mena nemôže byť zmenený po vykonaní položky pomocou inej mene
+apps/erpnext/erpnext/accounts/doctype/account/account.py +127,Currency can not be changed after making entries using some other currency,Mena nemôže byť zmenený po vykonaní položky pomocou inej mene
 DocType: Company,Round Off Account,Zaokrúhliť účet
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +87,Administrative Expenses,Administrativní náklady
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +91,Administrative Expenses,Administrativní náklady
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,Consulting
 DocType: Customer Group,Parent Customer Group,Parent Customer Group
-apps/erpnext/erpnext/public/js/pos/pos.js +455,Change,Zmena
 DocType: Purchase Invoice,Contact Email,Kontaktní e-mail
 DocType: Appraisal Goal,Score Earned,Skóre Zasloužené
-apps/erpnext/erpnext/public/js/setup_wizard.js +18,"e.g. ""My Company LLC""","napríklad ""Moja spoločnosť LLC """
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +173,Notice Period,Výpovedná Lehota
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +182,Notice Period,Výpovedná Lehota
 DocType: Asset Category,Asset Category Name,Asset názov kategórie
-DocType: Bank Reconciliation Detail,Voucher ID,Voucher ID
-apps/erpnext/erpnext/setup/doctype/territory/territory.js +14,This is a root territory and cannot be edited.,To je kořen území a nelze upravovat.
+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.
 DocType: Packing Slip,Gross Weight UOM,Hrubá Hmotnosť MJ
 DocType: Email Digest,Receivables / Payables,Pohledávky / Závazky
 DocType: Delivery Note Item,Against Sales Invoice,Proti prodejní faktuře
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +458,Credit Account,Úverový účet
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +469,Credit Account,Úverový účet
 DocType: Landed Cost Item,Landed Cost Item,Přistálo nákladovou položkou
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +56,Show zero values,Ukázat nulové hodnoty
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +55,Show zero values,Ukázat nulové hodnoty
 DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Množství položky získané po výrobě / přebalení z daných množství surovin
 DocType: Payment Reconciliation,Receivable / Payable Account,Pohledávky / závazky účet
 DocType: Delivery Note Item,Against Sales Order Item,Proti položce přijaté objednávky
-apps/erpnext/erpnext/stock/doctype/item/item.py +564,Please specify Attribute Value for attribute {0},Uveďte atribútu Hodnota atribútu {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +644,Please specify Attribute Value for attribute {0},Uveďte atribútu Hodnota atribútu {0}
 DocType: Item,Default Warehouse,Výchozí Warehouse
-DocType: Task,Actual End Date (via Time Logs),Skutočné Dátum ukončenia (cez Time Záznamy)
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +37,Budget cannot be assigned against Group Account {0},Rozpočet nemôže byť priradená na skupinový účet {0}
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +23,Please enter parent cost center,"Prosím, zadejte nákladové středisko mateřský"
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +39,Budget cannot be assigned against Group Account {0},Rozpočet nemôže byť priradená na skupinový účet {0}
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,"Prosím, zadejte nákladové středisko mateřský"
 DocType: Delivery Note,Print Without Amount,Tisknout bez Částka
-apps/erpnext/erpnext/controllers/buying_controller.py +61,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Daň z kategorie nemůže být ""Ocenění"" nebo ""Ocenění a celkový"", protože všechny položky jsou běžně skladem"
+apps/erpnext/erpnext/controllers/buying_controller.py +80,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Daň z kategorie nemůže být ""Ocenění"" nebo ""Ocenění a celkový"", protože všechny položky jsou běžně skladem"
 DocType: Issue,Support Team,Tým podpory
 DocType: Appraisal,Total Score (Out of 5),Celkové skóre (Out of 5)
 DocType: Batch,Batch,Šarže
-apps/erpnext/erpnext/stock/doctype/item/item.js +20,Balance,Zůstatek
+apps/erpnext/erpnext/stock/doctype/item/item.js +21,Balance,Zůstatek
 DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nárokov)
 DocType: Journal Entry,Debit Note,Debit Note
 DocType: Stock Entry,As per Stock UOM,Podľa skladovej MJ
@@ -3686,76 +3408,70 @@
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Sales Person,Prodej Osoba
 DocType: Sales Invoice,Cold Calling,Cold Calling
 DocType: SMS Parameter,SMS Parameter,SMS parametrů
-apps/erpnext/erpnext/config/accounts.py +192,Budget and Cost Center,Rozpočet a nákladového strediska
+apps/erpnext/erpnext/config/accounts.py +191,Budget and Cost Center,Rozpočet a nákladového strediska
 DocType: Maintenance Schedule Item,Half Yearly,Polročne
 DocType: Lead,Blog Subscriber,Blog Subscriber
-apps/erpnext/erpnext/config/setup.py +88,Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.
+apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Pokud je zaškrtnuto, Total no. pracovních dnů bude zahrnovat dovolenou, a to sníží hodnotu platu za každý den"
 DocType: Purchase Invoice,Total Advance,Total Advance
-apps/erpnext/erpnext/config/hr.py +257,Processing Payroll,Spracovanie miezd
+apps/erpnext/erpnext/config/hr.py +253,Processing Payroll,Spracovanie miezd
 DocType: Opportunity Item,Basic Rate,Základná sadzba
 DocType: GL Entry,Credit Amount,Výška úveru
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +139,Set as Lost,Nastaviť ako Nezískané
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +140,Set as Lost,Nastaviť ako Nezískané
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Doklad o zaplatení Note
 DocType: Supplier,Credit Days Based On,Úverové Dni Based On
 DocType: Tax Rule,Tax Rule,Daňové Pravidlo
 DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu
 DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovných hodín.
-apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +95,{0} {1} has already been submitted,{0} {1} už bolo odoslané
 ,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: Time Log,Billing Rate based on Activity Type (per hour),Účtovaná sadzba založená na typ aktivity (za hodinu)
 DocType: Company,Company Info,Informácie o spoločnosti
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +216,"Company Email ID not found, hence mail not sent","Společnost E-mail ID nebyl nalezen, proto pošta neodeslána"
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Aplikace fondů (aktiv)
-DocType: Purchase Invoice,Frequency,kmitočet
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +452,Debit Account,Debetné účet
+DocType: Sales Invoice,Frequency,kmitočet
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +463,Debit Account,Debetné účet
 DocType: Fiscal Year,Year Start Date,Dátom začiatku roka
 DocType: Attendance,Employee Name,Meno zamestnanca
 DocType: Sales Invoice,Rounded Total (Company Currency),Zaoblený Total (Company Měna)
-apps/erpnext/erpnext/accounts/doctype/account/account.py +95,Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
+apps/erpnext/erpnext/accounts/doctype/account/account.py +99,Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
 DocType: Purchase Common,Purchase Common,Nákup Common
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +93,{0} {1} has been modified. Please refresh.,{0} {1} bol zmenený. Prosím aktualizujte.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +218,{0} {1} has been modified. Please refresh.,{0} {1} bol zmenený. Prosím aktualizujte.
 DocType: Leave Block List,Stop users from making Leave Applications on following days.,Přestaňte uživatelům provádět Nechat aplikací v následujících dnech.
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +165,Supplier Quotation {0} created,Dodávateľ Cien {0} vytvoril
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +166,Employee Benefits,Zamestnanecké benefity
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +210,Supplier Quotation {0} created,Dodávateľ Cien {0} vytvoril
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +175,Employee Benefits,Zamestnanecké benefity
 DocType: Sales Invoice,Is POS,Je POS
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +230,Packed quantity must equal quantity for Item {0} in row {1},Balíčky množství se musí rovnat množství pro položku {0} v řadě {1}
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +234,Packed quantity must equal quantity for Item {0} in row {1},Balíčky množství se musí rovnat množství pro položku {0} v řadě {1}
 DocType: Production Order,Manufactured Qty,Vyrobeno Množství
 DocType: Purchase Receipt Item,Accepted Quantity,Schválené Množství
 apps/erpnext/erpnext/accounts/party.py +25,{0}: {1} does not exists,{0}: {1} neexistuje
 apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Směnky vznesené zákazníkům.
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID projektu
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +492,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},"Riadok č {0}: Čiastka nemôže byť väčšia ako Čakajúci Suma proti Expense nároku {1}. Do doby, než množstvo je {2}"
-apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.py +42,{0} subscribers added,{0} odberateľov pridaných
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +499,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},"Riadok č {0}: Čiastka nemôže byť väčšia ako Čakajúci Suma proti Expense nároku {1}. Do doby, než množstvo je {2}"
 DocType: Maintenance Schedule,Schedule,Plán
-DocType: Cost Center,"Define Budget for this Cost Center. To set budget action, see ""Company List""","Definovať rozpočtu pre tento nákladového strediska. Ak chcete nastaviť rozpočet akcie, pozri &quot;Zoznam firiem&quot;"
 DocType: Account,Parent Account,Nadřazený účet
 DocType: Quality Inspection Reading,Reading 3,Čtení 3
 ,Hub,Hub
 DocType: GL Entry,Voucher Type,Voucher Type
-apps/erpnext/erpnext/public/js/pos/pos.js +99,Price List not found or disabled,Ceník nebyl nalezen nebo zakázán
+apps/erpnext/erpnext/accounts/page/pos/pos.js +991,Price List not found or disabled,Ceník nebyl nalezen nebo zakázán
 DocType: Expense Claim,Approved,Schválený
 DocType: Pricing Rule,Price,Cena
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +99,Employee relieved on {0} must be set as 'Left',"Zaměstnanec úlevu na {0} musí být nastaven jako ""Left"""
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +167,Employee relieved on {0} must be set as 'Left',"Zaměstnanec úlevu na {0} musí být nastaven jako ""Left"""
 DocType: Item,"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","Výběrem ""Yes"" dá jedinečnou identitu každého subjektu této položky, které lze zobrazit v sériové číslo mistra."
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +39,Appraisal {0} created for Employee {1} in the given date range,Posouzení {0} vytvořil pro zaměstnance {1} v daném časovém období
 DocType: Employee,Education,Vzdělání
 DocType: Selling Settings,Campaign Naming By,Kampaň Pojmenování By
 DocType: Employee,Current Address Is,Aktuální adresa je
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +222,"Optional. Sets company's default currency, if not specified.","Voliteľné. Nastaví východiskovej mene spoločnosti, ak nie je uvedené."
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,"Optional. Sets company's default currency, if not specified.","Voliteľné. Nastaví východiskovej mene spoločnosti, ak nie je uvedené."
 DocType: Address,Office,Kancelář
-apps/erpnext/erpnext/config/accounts.py +50,Accounting journal entries.,Zápisy v účetním deníku.
+apps/erpnext/erpnext/config/accounts.py +55,Accounting journal entries.,Zápisy v účetním deníku.
 DocType: Delivery Note Item,Available Qty at From Warehouse,K dispozícii Množstvo na Od Warehouse
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +249,Please select Employee Record first.,"Prosím, vyberte zamestnanca záznam prvý."
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +190,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Riadok {0}: Party / Account nezhoduje s {1} / {2} do {3} {4}
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +35,To create a Tax Account,Chcete-li vytvořit daňovém účtu
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +239,Please enter Expense Account,"Prosím, zadejte výdajového účtu"
 DocType: Account,Stock,Sklad
 DocType: Employee,Current Address,Aktuální 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
-apps/erpnext/erpnext/config/stock.py +310,Batch Inventory,Batch Zásoby
+apps/erpnext/erpnext/config/stock.py +309,Batch Inventory,Batch Zásoby
 DocType: Employee,Contract End Date,Smlouva Datum ukončení
 DocType: Sales Order,Track this Sales Order against any Project,Sledovat tento prodejní objednávky na jakýkoli projekt
 DocType: Sales Invoice Item,Discount and Margin,Zľava a Margin
@@ -3763,11 +3479,10 @@
 DocType: Deduction Type,Deduction Type,Odpočet Type
 DocType: Attendance,Half Day,Pol deň
 DocType: Pricing Rule,Min Qty,Min Množství
-DocType: Features Setup,"To track items in sales and purchase documents with batch nos. ""Preferred Industry: Chemicals""",Ak chcete sledovať položky v oblasti predaja a nákupných dokladoch s číslami šarží. &quot;Výhodné Priemysel: Chemicals&quot;
-DocType: GL Entry,Transaction Date,Transakce Datum
+DocType: Asset Movement,Transaction Date,Transakce Datum
 DocType: Production Plan Item,Planned Qty,Plánované Množství
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +93,Total Tax,Total Tax
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +175,For Quantity (Manufactured Qty) is mandatory,Pre Množstvo (Vyrobené ks) je povinné
+apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +104,Total Tax,Total Tax
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +174,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)
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +78,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Riadok {0}: Typ Party Party a je použiteľná len proti pohľadávky / záväzky účtu
@@ -3775,41 +3490,34 @@
 DocType: Production Order,Actual Start Date,Skutečné datum zahájení
 DocType: Sales Order,% of materials delivered against this Sales Order,% materiálov dodaných proti tejto Predajnej objednávke
 apps/erpnext/erpnext/config/stock.py +12,Record item movement.,Záznam pohybu položka.
-DocType: Newsletter List Subscriber,Newsletter List Subscriber,Zoznam Newsletter účastníkov
 DocType: Hub Settings,Hub Settings,Nastavení Hub
 DocType: Project,Gross Margin %,Hrubá Marža %
 DocType: BOM,With Operations,S operacemi
-apps/erpnext/erpnext/accounts/party.py +234,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,"Položky účtovníctva už boli vykonané v mene, {0} pre firmu {1}. Vyberte pohľadávky a záväzku účet s menou {0}."
+apps/erpnext/erpnext/accounts/party.py +253,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,"Položky účtovníctva už boli vykonané v mene, {0} pre firmu {1}. Vyberte pohľadávky a záväzku účet s menou {0}."
 ,Monthly Salary Register,Měsíční plat Register
 DocType: Warranty Claim,If different than customer address,Pokud se liší od adresy zákazníka
 DocType: BOM Operation,BOM Operation,BOM Operation
 DocType: Purchase Taxes and Charges,On Previous Row Amount,Na předchozí řady Částka
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +33,Please enter Payment Amount in atleast one row,"Prosím, zadejte částku platby aspoň jedné řadě"
 DocType: POS Profile,POS Profile,POS Profile
-DocType: Payment Gateway Account,Payment URL Message,Platba URL Message
-apps/erpnext/erpnext/config/accounts.py +212,"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +242,Row {0}: Payment Amount cannot be greater than Outstanding Amount,Row {0}: Platba Částka nesmí být vyšší než dlužná částka
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +69,Total Unpaid,Celkom Neplatené
-apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +32,Time Log is not billable,Time Log není zúčtovatelné
-apps/erpnext/erpnext/stock/get_item_details.py +134,"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/config/accounts.py +215,"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
+apps/erpnext/erpnext/stock/get_item_details.py +129,"Item {0} is a template, please select one of its variants","Položka {0} je šablóna, prosím vyberte jednu z jeho variantov"
 DocType: Asset,Asset Category,asset Kategórie
-apps/erpnext/erpnext/public/js/setup_wizard.js +178,Purchaser,Nákupca
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +81,Net pay cannot be negative,Netto plat nemôže byť záporný
-apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +109,Please enter the Against Vouchers manually,Zadejte prosím podle dokladů ručně
+apps/erpnext/erpnext/public/js/setup_wizard.js +202,Purchaser,Nákupca
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +82,Net pay cannot be negative,Netto plat nemôže byť záporný
 DocType: SMS Settings,Static Parameters,Statické parametry
 DocType: Purchase Order,Advance Paid,Vyplacené zálohy
 DocType: Item,Item Tax,Daň Položky
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +639,Material to Supplier,Materiál Dodávateľovi
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +179,Excise Invoice,Spotrebný Faktúra
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +712,Material to Supplier,Materiál Dodávateľovi
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +189,Excise Invoice,Spotrebný Faktúra
 DocType: Expense Claim,Employees Email Id,Zaměstnanci Email Id
 DocType: Employee Attendance Tool,Marked Attendance,Výrazná Návštevnosť
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +162,Current Liabilities,Krátkodobé závazky
-apps/erpnext/erpnext/config/crm.py +127,Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +136,Current Liabilities,Krátkodobé závazky
+apps/erpnext/erpnext/config/selling.py +278,Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům
 DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Zvažte daň či poplatek za
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +59,Actual Qty is mandatory,Skutečné Množství je povinné
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +132,Credit Card,Kreditní karta
+apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +60,Actual Qty is mandatory,Skutočné množstvo je povinné
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +138,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/config/stock.py +175,Default settings for stock transactions.,Výchozí nastavení pro akciových transakcí.
+apps/erpnext/erpnext/config/stock.py +174,Default settings for stock transactions.,Výchozí nastavení pro akciových transakcí.
 DocType: Purchase Invoice,Next Date,Ďalší Dátum
 DocType: Employee Education,Major/Optional Subjects,Hlavní / Volitelné předměty
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +49,Please enter Taxes and Charges,"Prosím, zadejte Daně a poplatky"
@@ -3822,48 +3530,45 @@
 DocType: Stock Entry,Repack,Přebalit
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Musíte Uložte formulář před pokračováním
 DocType: Item Attribute,Numeric Values,Číselné hodnoty
-apps/erpnext/erpnext/public/js/setup_wizard.js +149,Attach Logo,Pripojiť Logo
-DocType: Customer,Commission Rate,Výše provize
-apps/erpnext/erpnext/stock/doctype/item/item.js +210,Make Variant,Vytvoriť Variant
+apps/erpnext/erpnext/public/js/setup_wizard.js +172,Attach Logo,Pripojiť Logo
+DocType: Customer,Commission Rate,Výška provízie
+apps/erpnext/erpnext/stock/doctype/item/item.js +253,Make Variant,Vytvoriť Variant
 apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Aplikace Block dovolené podle oddělení.
-apps/erpnext/erpnext/config/stock.py +201,Analytics,analytika
-apps/erpnext/erpnext/templates/pages/cart.html +51,Cart is Empty,Košík je prázdny
+apps/erpnext/erpnext/config/selling.py +169,Analytics,analytika
+apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +21,Cart is Empty,Košík je prázdny
 DocType: Production Order,Actual Operating Cost,Skutečné provozní náklady
-apps/erpnext/erpnext/accounts/doctype/account/account.py +80,Root cannot be edited.,Root nelze upravovat.
-apps/erpnext/erpnext/accounts/utils.py +197,Allocated amount can not greater than unadusted amount,Přidělená částka nemůže vyšší než částka unadusted
+apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root cannot be edited.,Root nelze upravovat.
 DocType: Manufacturing Settings,Allow Production on Holidays,Povolit Výrobu při dovolené
 DocType: Sales Order,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 +186,Capital Stock,Základný kapitál
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +160,Capital Stock,Základný kapitál
 DocType: Packing Slip,Package Weight Details,Hmotnost balení Podrobnosti
 DocType: Payment Gateway Account,Payment Gateway Account,Platobná brána účet
 DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Po dokončení platby presmerovať užívateľa na vybrané stránky.
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +102,Please select a csv file,Vyberte soubor csv
 DocType: Purchase Order,To Receive and Bill,Prijímať a Bill
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +94,Designer,Návrhář
-apps/erpnext/erpnext/config/selling.py +157,Terms and Conditions Template,Podmínky Template
+apps/erpnext/erpnext/config/selling.py +153,Terms and Conditions Template,Podmínky Template
 DocType: Serial No,Delivery Details,Zasílání
-DocType: Asset,Current Value (After Depreciation),Current Value (po odpise)
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +380,Cost Center is required in row {0} in Taxes table for type {1},Nákladové středisko je nutné v řadě {0} na daních tabulka typu {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +469,Cost Center is required in row {0} in Taxes table for type {1},Nákladové středisko je nutné v řadě {0} na daních tabulka typu {1}
 ,Item-wise Purchase Register,Item-moudrý Nákup Register
 DocType: Batch,Expiry Date,Datum vypršení platnosti
-apps/erpnext/erpnext/stock/doctype/item/item.py +413,"To set reorder level, item must be a Purchase Item or Manufacturing Item","Ak chcete nastaviť úroveň objednávacie, položka musí byť Nákup položka alebo výrobné položky"
 ,Supplier Addresses and Contacts,Dodavatel Adresy a kontakty
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +268,Please select Category first,Nejdřív vyberte kategorii
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +292,Please select Category first,Nejdřív vyberte kategorii
 apps/erpnext/erpnext/config/projects.py +13,Project master.,Master Project.
 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/leave_application/leave_application.py +407, (Half Day),(Pol dňa)
 DocType: Supplier,Credit Days,Úvěrové dny
 DocType: Leave Type,Is Carry Forward,Je převádět
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +602,Get Items from BOM,Získat předměty z BOM
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +687,Get Items from BOM,Získat předměty z BOM
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Lead Time Days
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +129,Please enter Sales Orders in the above table,"Prosím, zadajte Predajné objednávky v tabuľke vyššie"
-apps/erpnext/erpnext/config/manufacturing.py +33,Bill of Materials,Kusovník
+apps/erpnext/erpnext/config/learn.py +222,Bill of Materials,Kusovník
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +76,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Riadok {0}: Typ Party Party a je nutné pre pohľadávky / záväzky na účte {1}
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +102,Ref Date,Ref Datum
 DocType: Employee,Reason for Leaving,Důvod Leaving
 DocType: Expense Claim Detail,Sanctioned Amount,Sankcionována Částka
 DocType: GL Entry,Is Opening,Se otevírá
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +169,Row {0}: Debit entry can not be linked with a {1},Row {0}: záporný nemůže být spojována s {1}
-apps/erpnext/erpnext/accounts/doctype/account/account.py +209,Account {0} does not exist,Účet {0} neexistuje
+apps/erpnext/erpnext/accounts/doctype/account/account.py +218,Account {0} does not exist,Účet {0} neexistuje
 DocType: Account,Cash,V hotovosti
 DocType: Employee,Short biography for website and other publications.,Krátký životopis na internetové stránky a dalších publikací.
