diff --git a/erpnext/translations/cs.csv b/erpnext/translations/cs.csv
index bbd251b..4dd1fd6 100644
--- a/erpnext/translations/cs.csv
+++ b/erpnext/translations/cs.csv
@@ -3,12 +3,12 @@
 DocType: Patient,Divorced,Rozvedený
 DocType: Buying Settings,Allow Item to be added multiple times in a transaction,"Povolit položky, které se přidávají vícekrát v transakci"
 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/data/industry_type.py +19,Consumer Products,Spotřební zboží
 DocType: Purchase Receipt,Subscription Detail,Detail předplatného
 DocType: Supplier Scorecard,Notify Supplier,Informujte dodavatele
 DocType: Item,Customer Items,Zákazník položky
 DocType: Project,Costing and Billing,Kalkulace a fakturace
-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
+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
 DocType: Item,Publish Item to hub.erpnext.com,Publikování položku do hub.erpnext.com
 apps/erpnext/erpnext/config/setup.py +88,Email Notifications,E-mailová upozornění
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,ohodnocení
@@ -20,10 +20,9 @@
 DocType: Restaurant Order Entry,Click Enter To Add,Klepněte na tlačítko Zadat pro přidání
 DocType: Employee,Rented,Pronajato
 DocType: Purchase Order,PO-,po-
-DocType: POS Profile,Applicable for User,Použitelné pro Uživatele
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +196,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Zastavil výrobu Objednat nelze zrušit, uvolnit ho nejprve zrušit"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Zastavil výrobu Objednat nelze zrušit, uvolnit ho nejprve zrušit"
 DocType: Vehicle Service,Mileage,Najeto
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +220,Do you really want to scrap this asset?,Opravdu chcete zrušit tuto pohledávku?
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +240,Do you really want to scrap this asset?,Opravdu chcete zrušit tuto pohledávku?
 DocType: Drug Prescription,Update Schedule,Aktualizovat plán
 apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Vybrat Výchozí Dodavatel
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Měna je vyžadováno pro Ceníku {0}
@@ -32,8 +31,8 @@
 DocType: Patient Appointment,Check availability,Zkontrolujte dostupnost
 DocType: Job Applicant,Job Applicant,Job Žadatel
 apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,To je založeno na transakcích proti tomuto dodavateli. Viz časovou osu níže podrobnosti
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +34,Legal,Právní
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Actual type tax cannot be included in Item rate in row {0},Aktuální typ daň nemůže být zahrnutý v ceně Položka v řádku {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Právní
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Aktuální typ daň nemůže být zahrnutý v ceně Položka v řádku {0}
 DocType: Bank Guarantee,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
@@ -41,79 +40,91 @@
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Exchange Rate musí být stejná jako {0} {1} ({2})
 DocType: Sales Invoice,Customer Name,Jméno zákazníka
 DocType: Vehicle,Natural Gas,Zemní plyn
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +120,Bank account cannot be named as {0},Bankovní účet nemůže být jmenován jako {0}
+apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Bankovní účet nemůže být jmenován jako {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 +196,Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1})
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +357,There are no submitted Salary Slips to process.,Neprovádějí se žádné předání platů.
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Neprovádějí se žádné předání platů.
 DocType: Manufacturing Settings,Default 10 mins,Výchozí 10 min
 DocType: Leave Type,Leave Type Name,Jméno typu absence
 apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Ukázat otevřené
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Je nutné tuto akci učinit i dnes pro výše uvedené opakování
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Řada Aktualizováno Úspěšně
 apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Odhlásit se
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +175,Accural Journal Entry Submitted,Accural Zápis do deníku Vložené
 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: Support Settings,Support Settings,Nastavení podpůrných
-apps/erpnext/erpnext/projects/doctype/project/project.py +70,Expected End Date can not be less than Expected Start Date,"Očekávané Datum ukončení nemůže být nižší, než se očekávalo data zahájení"
+apps/erpnext/erpnext/projects/doctype/project/project.py +72,Expected End Date can not be less than Expected Start Date,"Očekávané Datum ukončení nemůže být nižší, než se očekávalo data zahájení"
 apps/erpnext/erpnext/utilities/transaction_base.py +110,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Řádek # {0}: Cena musí být stejné, jako {1}: {2} ({3} / {4})"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,New Leave Application
 ,Batch Item Expiry Status,Batch položky vypršení platnosti Stav
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +180,Bank Draft,Bank Návrh
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Bank Návrh
+DocType: Membership,membership validaty section,členství platná část
 DocType: Mode of Payment Account,Mode of Payment Account,Způsob platby účtu
 DocType: Consultation,Consultation,Konzultace
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +21,Sales and Returns,Prodej a výnosy
+DocType: Accounts Settings,Show Payment Schedule in Print,Zobrazit plán placení v tisku
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Prodej a výnosy
 apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Zobrazit Varianty
 DocType: Academic Term,Academic Term,Akademický Term
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiál
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +670,Quantity,Množství
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Účty tabulka nemůže být prázdné.
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Vytváření webových stránek
+DocType: Opening Invoice Creation Tool Item,Quantity,Množství
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +544,Accounts table cannot be blank.,Účty tabulka nemůže být prázdné.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Úvěry (závazky)
 DocType: Employee Education,Year of Passing,Rok Passing
 DocType: Item,Country of Origin,Země původu
+DocType: Soil Texture,Soil Texture Criteria,Kritéria textury půdy
 apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,Na skladě
+apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Primární kontaktní údaje
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,otevřené problémy
 DocType: Production Plan Item,Production Plan Item,Výrobní program Item
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1}
 DocType: Lab Test Groups,Add new line,Přidat nový řádek
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +31,Health Care,Péče o zdraví
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Péče o zdraví
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Zpoždění s platbou (dny)
+DocType: Payment Terms Template Detail,Payment Terms Template Detail,Platební podmínky
 DocType: Lab Prescription,Lab Prescription,Lab Předpis
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +185,Sort by Price,Seřadit podle ceny
 apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Service Expense
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +888,Serial Number: {0} is already referenced in Sales Invoice: {1},Sériové číslo: {0} je již uvedeno v prodejní faktuře: {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +849,Invoice,Faktura
-DocType: Maintenance Schedule Item,Periodicity,Periodicita
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +893,Serial Number: {0} is already referenced in Sales Invoice: {1},Sériové číslo: {0} je již uvedeno v prodejní faktuře: {1}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Invoice,Faktura
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +109,Make Retention Stock Entry,Zadejte retenční položku
+DocType: Purchase Invoice Item,Item Weight Details,Položka podrobnosti o hmotnosti
+DocType: Asset Maintenance Log,Periodicity,Periodicita
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Fiskální rok {0} je vyžadována
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +21,Defense,Obrana
+DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,Minimální vzdálenost mezi řadami rostlin pro optimální růst
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Obrana
 DocType: Salary Component,Abbr,Zkr
 DocType: Appraisal Goal,Score (0-5),Score (0-5)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225,Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} se neshoduje s {3}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +223,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 +75,Row # {0}:,Řádek č. {0}:
 DocType: Timesheet,Total Costing Amount,Celková kalkulace Částka
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Skupina zákazníků&gt; Území
 DocType: Delivery Note,Vehicle No,Vozidle
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +160,Please select Price List,"Prosím, vyberte Ceník"
 DocType: Accounts Settings,Currency Exchange Settings,Nastavení směnného kurzu
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Řádek # {0}: Platba dokument je nutné k dokončení trasaction
 DocType: Production Order Operation,Work In Progress,Na cestě
-apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +13,Please select date,"Prosím, vyberte datum"
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,"Prosím, vyberte datum"
 DocType: Employee,Holiday List,Seznam dovolené
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +123,Accountant,Účetní
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Účetní
 DocType: Hub Settings,Selling Price List,Prodejní ceník
 DocType: Patient,Tobacco Current Use,Aktuální tabákové použití
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +21,Selling Rate,Prodejní sazba
 DocType: Cost Center,Stock User,Sklad Uživatel
+DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
 DocType: Company,Phone No,Telefon
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +50,Course Schedules created:,Plány kurzu vytvořil:
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +237,New {0}: #{1},Nový {0}: # {1}
+DocType: Delivery Trip,Initial Email Notification Sent,Původní e-mailové oznámení bylo odesláno
 ,Sales Partners Commission,Obchodní partneři Komise
+DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
 DocType: Purchase Invoice,Rounding Adjustment,Nastavení zaoblení
 apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Zkratka nesmí mít více než 5 znaků
 DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Lékařský časový plán
 DocType: Payment Request,Payment Request,Platba Poptávka
 DocType: Asset,Value After Depreciation,Hodnota po odpisech
-DocType: Employee,O+,O +
+DocType: Student,O+,O +
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,Příbuzný
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,Datum návštěvnost nemůže být nižší než spojovací data zaměstnance
 DocType: Grading Scale,Grading Scale Name,Klasifikační stupnice Name
@@ -123,153 +134,157 @@
 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","Připojit CSV soubor se dvěma sloupci, jeden pro starý název a jeden pro nový název"
-apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} není v žádném aktivní fiskální rok.
+apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} není v žádném aktivním fiskální rok.
 DocType: Packed Item,Parent Detail docname,Parent Detail docname
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Odkaz: {0}, kód položky: {1} a zákazník: {2}"
-apps/erpnext/erpnext/utilities/user_progress.py +125,Kg,Kg
+apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,Kg
 apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Otevření o zaměstnání.
-apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +147,{0} Result submittted,{0} Výsledek byl předložen
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +103,BOM is not specified for subcontracting item {0} at row {1},Kusovník není zadán pro subdodavatelskou položku {0} na řádku {1}
+apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Výsledek byl předložen
 DocType: Item Attribute,Increment,Přírůstek
 apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +61,Timespan,Časové rozpětí
 apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Vyberte sklad ...
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +6,Advertising,Reklama
+apps/erpnext/erpnext/setup/setup_wizard/data/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,Stejný Společnost je zapsána více než jednou
 DocType: Patient,Married,Ženatý
 apps/erpnext/erpnext/accounts/party.py +44,Not permitted for {0},Není dovoleno {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +568,Get items from,Položka získaná z
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +457,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 +593,Get items from,Položka získaná z
+DocType: Price List,Price Not UOM Dependant,Cena není závislá na UOM
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +461,Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
 apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produkt {0}
 apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Žádné položky nejsou uvedeny
+DocType: Asset Repair,Error Description,Popis chyby
 DocType: Payment Reconciliation,Reconcile,Srovnat
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,Potraviny
+apps/erpnext/erpnext/setup/setup_wizard/data/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/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Vedle Odpisy datum nemůže být před zakoupením Datum
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Penzijní fondy
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Vedle Odpisy datum nemůže být před zakoupením Datum
+DocType: Crop,Perennial,Trvalka
 DocType: Consultation,Consultation Date,Datum konzultace
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +131,Product listing and discovery for ERPNext users,Výpis produktů a objevy pro uživatele ERPNext
 DocType: SMS Center,All Sales Person,Všichni obchodní zástupci
 DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Měsíční Distribuce ** umožňuje distribuovat Rozpočet / Target celé měsíce, pokud máte sezónnosti ve vaší firmě."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1727,Not items found,Nebyl nalezen položek
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1742,Not items found,Nebyl nalezen položek
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Plat Struktura Chybějící
 DocType: Lead,Person Name,Osoba Jméno
 DocType: Sales Invoice Item,Sales Invoice Item,Položka prodejní faktury
 DocType: Account,Credit,Úvěr
 DocType: POS Profile,Write Off Cost Center,Odepsat nákladové středisko
-apps/erpnext/erpnext/public/js/setup_wizard.js +114,"e.g. ""Primary School"" or ""University""",například &quot;Základní škola&quot; nebo &quot;univerzita&quot;
-apps/erpnext/erpnext/config/stock.py +32,Stock Reports,Stock Reports
+apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",například &quot;Základní škola&quot; nebo &quot;univerzita&quot;
+apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Stock Reports
 DocType: Warehouse,Warehouse Detail,Sklad Detail
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +164,Credit limit has been crossed for customer {0} {1}/{2},Úvěrový limit byla překročena o zákazníka {0} {1} / {2}
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termínovaný Datum ukončení nemůže být později než v roce Datum ukončení akademického roku, ke kterému termín je spojena (akademický rok {}). Opravte data a zkuste to znovu."
-apps/erpnext/erpnext/stock/doctype/item/item.py +479,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Je Fixed Asset&quot; nemůže být bez povšimnutí, protože existuje Asset záznam proti položce"
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +192,Credit limit has been crossed for customer {0} {1}/{2},Úvěrový limit byla překročena o zákazníka {0} {1} / {2}
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termínovaný Datum ukončení nemůže být později než v roce Datum ukončení akademického roku, ke kterému termín je spojena (akademický rok {}). Opravte data a zkuste to znovu."
+apps/erpnext/erpnext/stock/doctype/item/item.py +258,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","""Je dlouhodobý majetek"" nemůže být nezaškrtnutý protože existuje zápis aktiva oproti této položce"
+DocType: Delivery Trip,Departure Time,Čas odjezdu
 DocType: Vehicle Service,Brake Oil,Brake Oil
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Skupina zákazníků&gt; Území
 DocType: Tax Rule,Tax Type,Daňové Type
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +555,Taxable Amount,Zdanitelná částka
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +561,Taxable Amount,Zdanitelná částka
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
 DocType: BOM,Item Image (if not slideshow),Item Image (ne-li slideshow)
 DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hodinová sazba / 60) * Skutečný čas operace
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1050,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Řádek # {0}: Referenční typ dokumentu musí být jedním z nákladového tvrzení nebo záznamu v deníku
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +917,Select BOM,Vybrat BOM
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Řádek # {0}: Referenční typ dokumentu musí být jedním z nákladového tvrzení nebo záznamu v deníku
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +964,Select BOM,Vybrat BOM
 DocType: SMS Log,SMS Log,SMS Log
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Náklady na dodávaných výrobků
+apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Spravujte zálohu poskytnutou zaměstnanci
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Dovolená na {0} není mezi Datum od a do dnešního dne
 DocType: Student Log,Student Log,Student Log
 DocType: Quality Inspection,Get Specification Details,Získat Specifikace Podrobnosti
 apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Šablony dodavatelů.
 DocType: Lead,Interested,Zájemci
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +171,Opening,Otvor
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +28,From {0} to {1},Od {0} do {1}
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +219,Opening,Otvor
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +29,From {0} to {1},Od {0} do {1}
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Nepodařilo se nastavit daně
 DocType: Item,Copy From Item Group,Kopírovat z bodu Group
+DocType: Delivery Trip,Delivery Notification,Oznámení o doručení
 DocType: Journal Entry,Opening Entry,Otevření Entry
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Účet Pay Pouze
 DocType: Employee Loan,Repay Over Number of Periods,Splatit Over počet období
 DocType: Stock Entry,Additional Costs,Dodatečné náklady
-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.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +140,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
-DocType: Academic Term,Schools,školy
-DocType: School Settings,Validate Batch for Students in Student Group,Ověřit dávku pro studenty ve skupině studentů
+DocType: Education Settings,Validate Batch for Students in Student Group,Ověřit dávku pro studenty ve skupině studentů
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Žádný záznam volno nalezených pro zaměstnance {0} na {1}
 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 +358,Please select Company first,"Prosím, vyberte první firma"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,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
+DocType: Soil Analysis,Ca/K,Ca / K
 DocType: Journal Entry Account,Employee Loan,zaměstnanec Loan
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +108,Activity Log:,Aktivita Log:
 DocType: Fee Schedule,Send Payment Request Email,Odeslat e-mail s žádostí o platbu
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +256,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/manufacturing/doctype/bom/bom.py +259,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/data/industry_type.py +44,Real Estate,Nemovitost
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Výpis z účtu
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +41,Pharmaceuticals,Farmaceutické
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Farmaceutické
 DocType: Purchase Invoice Item,Is Fixed Asset,Je dlouhodobý majetek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +234,"Available qty is {0}, you need {1}","K dispozici je množství {0}, musíte {1}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +251,"Available qty is {0}, you need {1}","K dispozici je množství {0}, musíte {1}"
 DocType: Expense Claim Detail,Claim Amount,Nárok Částka
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +51,Duplicate customer group found in the cutomer group table,Duplicitní skupinu zákazníků uvedeny v tabulce na knihy zákazníků skupiny
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Duplicitní skupinu zákazníků uvedeny v tabulce na knihy zákazníků skupiny
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Dodavatel Typ / dovozce
 DocType: Naming Series,Prefix,Prefix
 apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Umístění události
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +64,Consumable,Spotřební
-DocType: Employee,B-,B-
-DocType: Upload Attendance,Import Log,Záznam importu
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Spotřební
+DocType: Student,B-,B-
 DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Vytáhněte Materiál Žádost typu Výroba na základě výše uvedených kritérií
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +100,Successfully unregistered.,Úspěšně bylo zrušeno registrace.
-DocType: Training Result Employee,Grade,Školní známka
+DocType: Assessment Result,Grade,Školní známka
 DocType: Restaurant Table,No of Seats,Počet sedadel
 DocType: Subscription,"To add dynamic subject, use jinja tags like
 
 <div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Chcete-li přidat dynamický objekt, použijte jinja tagy jako <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
 DocType: Sales Invoice Item,Delivered By Supplier,Dodává se podle dodavatele
+DocType: Asset Maintenance Task,Asset Maintenance Task,Úloha údržby aktiv
 DocType: SMS Center,All Contact,Vše Kontakt
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +905,Production Order already created for all items with BOM,Výrobní zakázka již vytvořili u všech položek s BOM
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +220,Annual Salary,Roční Plat
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +952,Production Order already created for all items with BOM,Výrobní zakázka již vytvořili u všech položek s BOM
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +230,Annual Salary,Roční Plat
 DocType: Daily Work Summary,Daily Work Summary,Denní práce Souhrn
 DocType: Period Closing Voucher,Closing Fiscal Year,Uzavření fiskálního roku
-apps/erpnext/erpnext/accounts/party.py +368,{0} {1} is frozen,{0} {1} je zmrazený
-apps/erpnext/erpnext/setup/doctype/company/company.py +132,Please select Existing Company for creating Chart of Accounts,Vyberte existující společnosti pro vytváření účtový rozvrh
+apps/erpnext/erpnext/accounts/party.py +380,{0} {1} is frozen,{0} {1} je zmrazený
+apps/erpnext/erpnext/setup/doctype/company/company.py +129,Please select Existing Company for creating Chart of Accounts,Vyberte existující společnosti pro vytváření účtový rozvrh
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Stock Náklady
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +96,Select Target Warehouse,Vyberte objekt Target Warehouse
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Vyberte objekt Target Warehouse
 apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,"Prosím, zadejte Preferred Kontakt e-mail"
-DocType: Program Enrollment,School Bus,Školní autobus
 DocType: Journal Entry,Contra Entry,Contra Entry
 DocType: Journal Entry Account,Credit in Company Currency,Úvěrové společnosti v měně
 DocType: Lab Test UOM,Lab Test UOM,Laboratorní test UOM
 DocType: Delivery Note,Installation Status,Stav instalace
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
 					<br>Absent: {1}",Chcete aktualizovat docházku? <br> Present: {0} \ <br> Chybí: {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +325,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 +326,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: Request for Quotation,RFQ-,RFQ-
 DocType: Item,Supply Raw Materials for Purchase,Dodávky suroviny pro nákup
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +149,At least one mode of payment is required for POS invoice.,pro POS fakturu je nutná alespoň jeden způsob platby.
+DocType: Agriculture Analysis Criteria,Fertilizer,Hnojivo
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +150,At least one mode of payment is required for POS invoice.,pro POS fakturu je nutná alespoň jeden způsob platby.
 DocType: Products Settings,Show Products as a List,Zobrazit produkty jako seznam
-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 +482,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/stock/doctype/stock_entry/stock_entry.py +507,Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
 DocType: Student Admission Program,Minimum Age,Minimální věk
-apps/erpnext/erpnext/utilities/user_progress.py +169,Example: Basic Mathematics,Příklad: Základní Mathematics
-apps/erpnext/erpnext/controllers/accounts_controller.py +657,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","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 +218,Settings for HR Module,Nastavení pro HR modul
+apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Příklad: Základní Mathematics
+apps/erpnext/erpnext/controllers/accounts_controller.py +769,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","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 +223,Settings for HR Module,Nastavení pro HR modul
 DocType: SMS Center,SMS Center,SMS centrum
 DocType: Sales Invoice,Change Amount,změna Částka
 DocType: BOM Update Tool,New BOM,Nový BOM
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +117,Please enter Delivery Date,Zadejte prosím datum doručení
+DocType: Driver,Driving License Categories,Kategorie řidičských oprávnění
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Zadejte prosím datum doručení
 DocType: Depreciation Schedule,Make Depreciation Entry,Udělat Odpisy Entry
 DocType: Appraisal Template Goal,KRA,KRA
 DocType: Lead,Request Type,Typ požadavku
 apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,Udělat zaměstnance
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +14,Broadcasting,Vysílání
-apps/erpnext/erpnext/config/accounts.py +321,Setup mode of POS (Online / Offline),Režim nastavení POS (Online / Offline)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +187,Execution,Provedení
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Vysílání
+apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Režim nastavení POS (Online / Offline)
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,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/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dodavatel je nutná proti zaplacení účtu {2}
+DocType: Asset Maintenance Log,Maintenance Status,Status Maintenance
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Podrobnosti o členství
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dodavatel je vyžadován oproti splatnému účtu {2}
 apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Položky a Ceny
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Celkem hodin: {0}
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},"Od data by měla být v rámci fiskálního roku. Za předpokladu, že od data = {0}"
 DocType: Drug Prescription,Interval,Interval
-DocType: Customer,Individual,Individuální
-DocType: Interest,Academics User,akademici Uživatel
+DocType: Grant Application,Individual,Individuální
+DocType: Academic Term,Academics User,akademici Uživatel
 DocType: Cheque Print Template,Amount In Figure,Na obrázku výše
 DocType: Employee Loan Application,Loan Info,Informace o úvěr
 apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plán pro návštěvy údržby.
@@ -282,17 +297,19 @@
 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 (%),Sleva na Ceník Rate (%)
-apps/erpnext/erpnext/healthcare/setup.py +214,Biochemistry,Biochemie
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Šablona položky
+apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biochemie
 DocType: Offer Letter,Select Terms and Conditions,Vyberte Podmínky
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +60,Out Value,limitu
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,limitu
 DocType: Production Planning Tool,Sales Orders,Prodejní objednávky
 DocType: Purchase Taxes and Charges,Valuation,Ocenění
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +373,Set as Default,Nastavit jako výchozí
 ,Purchase Order Trends,Nákupní objednávka trendy
 apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Přejděte na položku Zákazníci
 apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Žádost o cenovou nabídku lze přistupovat kliknutím na následující odkaz
 apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Přidělit listy za rok.
 DocType: SG Creation Tool Course,SG Creation Tool Course,SG nástroj pro tvorbu hřiště
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +236,Insufficient Stock,nedostatečná Sklad
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,Insufficient Stock,nedostatečná Sklad
 DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Zakázat Plánování kapacit a Time Tracking
 DocType: Email Digest,New Sales Orders,Nové Prodejní objednávky
 DocType: Bank Guarantee,Bank Account,Bankovní účet
@@ -300,67 +317,69 @@
 apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Nelze odstranit typ projektu &quot;Externí&quot;
 DocType: Employee,Create User,Vytvořit uživatele
 DocType: Selling Settings,Default Territory,Výchozí Territory
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Televize
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televize
 DocType: Production Order Operation,Updated via 'Time Log',"Aktualizováno přes ""Time Log"""
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +427,Advance amount cannot be greater than {0} {1},Množství předem nemůže být větší než {0} {1}
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +428,Advance amount cannot be greater than {0} {1},Množství předem nemůže být větší než {0} {1}
 DocType: Naming Series,Series List for this Transaction,Řada seznam pro tuto transakci
 DocType: Company,Enable Perpetual Inventory,Povolit trvalý inventář
 DocType: Company,Default Payroll Payable Account,"Výchozí mzdy, splatnou Account"
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +51,Update Email Group,Aktualizace Email Group
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Aktualizace Email Group
 DocType: Sales Invoice,Is Opening Entry,Je vstupní otvor
 DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Pokud není zaškrtnuto, bude položka zobrazena v faktuře prodeje, ale může být použita při vytváření skupinových testů."
 DocType: Customer Group,Mention if non-standard receivable account applicable,Zmínka v případě nestandardní pohledávky účet použitelná
 DocType: Course Schedule,Instructor Name,instruktor Name
 DocType: Supplier Scorecard,Criteria Setup,Nastavení kritérií
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +179,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 +199,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,Přijaté On
 DocType: Sales Partner,Reseller,Reseller
 DocType: Codification Table,Medical Code,Lékařský zákoník
 DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Zda zaškrtnuto, zahrne neskladové položky v požadavcích materiálu."
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,"Prosím, zadejte společnost"
 DocType: Delivery Note Item,Against Sales Invoice Item,Proti položce vydané faktury
+DocType: Agriculture Analysis Criteria,Linked Doctype,Linked Doctype
 ,Production Orders in Progress,Zakázka na výrobu v Progress
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Čistý peněžní tok z financování
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2313,"LocalStorage is full , did not save","Místní úložiště je plná, nezachránil"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2332,"LocalStorage is full , did not save","Místní úložiště je plná, nezachránil"
 DocType: Lead,Address & Contact,Adresa a kontakt
 DocType: Leave Allocation,Add unused leaves from previous allocations,Přidat nevyužité listy z předchozích přídělů
 DocType: Sales Partner,Partner website,webové stránky Partner
 DocType: Restaurant Order Entry,Add Item,Přidat položku
 DocType: Lab Test,Custom Result,Vlastní výsledek
-apps/erpnext/erpnext/utilities/user_progress.py +71,Contact Name,Kontakt Jméno
+DocType: Delivery Stop,Contact Name,Kontakt Jméno
 DocType: Course Assessment Criteria,Course Assessment Criteria,Hodnotící kritéria hřiště
-DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Vytvoří výplatní pásku na výše uvedených kritérií.
 DocType: POS Customer Group,POS Customer Group,POS Customer Group
+DocType: Land Unit,Land Unit describing various land assets,Pozemní jednotka popisující různé pozemky
 DocType: Cheque Print Template,Line spacing for amount in words,řádkování za částku ve slovech
 DocType: Vehicle,Additional Details,další detaily
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Plán hodnocení:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Plán hodnocení:
 apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,No vzhledem k tomu popis
 apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Žádost o koupi.
 DocType: Lab Test,Submitted Date,Datum odeslání
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,To je založeno na časových výkazů vytvořených proti tomuto projektu
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +390,Net Pay cannot be less than 0,Čistý Pay nemůže být nižší než 0
+DocType: Payment Term,Credit Months,Kreditní měsíce
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Čistý Pay nemůže být nižší než 0
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Chcete-li zastavit odesílání upozornění na opakované chyby ze systému, jsme v odběru zkontrolovali pole Zakázáno"
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,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 +116,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 +228,Leaves per Year,Dovolených za rok
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Zkontrolujte ""Je Advance"" proti účtu {1}, pokud je to záloha záznam."
-apps/erpnext/erpnext/stock/utils.py +212,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,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/operations/install_fixtures.py +238,Leaves per Year,Dovolených za rok
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +128,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Zkontrolujte ""Je Advance"" proti účtu {1}, pokud je to záloha záznam."
+apps/erpnext/erpnext/stock/utils.py +217,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
 DocType: Email Digest,Profit & Loss,Ztráta zisku
-apps/erpnext/erpnext/utilities/user_progress.py +126,Litre,Litr
+apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Litr
 DocType: Task,Total Costing Amount (via Time Sheet),Celková kalkulace Částka (přes Time Sheet)
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.py +63,Please setup Students under Student Groups,"Prosím, nastavte studenty pod studentskými skupinami"
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,"Prosím, nastavte studenty pod studentskými skupinami"
 DocType: Item Website Specification,Item Website Specification,Položka webových stránek Specifikace
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +477,Leave Blocked,Absence blokována
-apps/erpnext/erpnext/stock/doctype/item/item.py +723,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 +88,Bank Entries,bankovní Příspěvky
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +119,Annual,Roční
+apps/erpnext/erpnext/stock/doctype/item/item.py +709,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 +99,Bank Entries,bankovní Příspěvky
+DocType: Crop,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: Student Group Creation Tool Course,Student Group Creation Tool Course,Student Group Creation Tool hřiště
 DocType: Lead,Do Not Contact,Nekontaktujte
-apps/erpnext/erpnext/utilities/user_progress.py +189,People who teach at your organisation,"Lidé, kteří vyučují ve vaší organizaci"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +131,Software Developer,Software Developer
+apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,"Lidé, kteří vyučují ve vaší organizaci"
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Software Developer
 DocType: Item,Minimum Order Qty,Minimální objednávka Množství
 DocType: Pricing Rule,Supplier Type,Dodavatel Type
 DocType: Course Scheduling Tool,Course Start Date,Začátek Samozřejmě Datum
@@ -369,58 +388,64 @@
 DocType: Item,Publish in Hub,Publikovat v Hub
 DocType: Student Admission,Student Admission,Student Vstupné
 ,Terretory,Terretory
-apps/erpnext/erpnext/stock/doctype/item/item.py +743,Item {0} is cancelled,Položka {0} je zrušen
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +923,Material Request,Požadavek na materiál
+apps/erpnext/erpnext/stock/doctype/item/item.py +729,Item {0} is cancelled,Položka {0} je zrušen
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,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 +357,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebyl nalezen v &quot;suroviny dodané&quot; tabulky v objednávce {1}
-DocType: Patient Relation,Relation,Vztah
-DocType: Shipping Rule,Worldwide Shipping,Celosvětově doprava
-DocType: Patient Relation,Mother,Matka
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +382,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebyl nalezen v &quot;suroviny dodané&quot; tabulky v objednávce {1}
+DocType: Salary Slip,Total Principal Amount,Celková hlavní částka
+DocType: Student Guardian,Relation,Vztah
+DocType: Student Guardian,Mother,Matka
 DocType: Restaurant Reservation,Reservation End Time,Doba ukončení rezervace
+DocType: Crop,Biennial,Dvouletý
 apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
 DocType: Purchase Receipt Item,Rejected Quantity,Odmíntnuté množství
-apps/erpnext/erpnext/schools/doctype/fees/fees.py +80,Payment request {0} created,Byla vytvořena žádost o platbu {0}
-apps/erpnext/erpnext/healthcare/setup.py +254,Low Sensitivity,Nízká citlivost
+apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Byla vytvořena žádost o platbu {0}
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Otevřené objednávky
+apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Nízká citlivost
 DocType: Notification Control,Notification Control,Oznámení Control
 apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Potvrďte prosím po dokončení školení
 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.
+DocType: Payment Term,Payment Term Name,Název platebního termínu
 DocType: Healthcare Settings,Create documents for sample collection,Vytvořte dokumenty pro výběr vzorků
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Platba proti {0} {1} nemůže být větší než dlužné částky {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +274,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Platba proti {0} {1} nemůže být větší než dlužné částky {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/payment_entry/payment_entry.js +146,Please select Charge Type first,"Prosím, vyberte druh tarifu první"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +163,Please select Charge Type first,"Prosím, vyberte druh tarifu první"
+DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Můžete definovat všechny úkoly, které je třeba provést pro tuto plodinu zde. Denní pole se používá k uvedení den, kdy má být úkol proveden, 1 je 1. den atd."
 DocType: Student Group Student,Student Group Student,Student Skupina Student
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Nejnovější
+DocType: Asset Maintenance Task,2 Yearly,2 Každoročně
+DocType: Education Settings,Education Settings,Nastavení vzdělávání
 DocType: Vehicle Service,Inspection,Inspekce
 DocType: Supplier Scorecard Scoring Standing,Max Grade,Max stupeň
 DocType: Email Digest,New Quotations,Nové Citace
 DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,"E-maily výplatní pásce, aby zaměstnanci na základě přednostního e-mailu vybraného v zaměstnaneckých"
 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
 DocType: Tax Rule,Shipping County,vodní doprava County
-apps/erpnext/erpnext/config/desktop.py +159,Learn,Učit se
+apps/erpnext/erpnext/config/desktop.py +167,Learn,Učit se
 DocType: Asset,Next Depreciation Date,Vedle Odpisy Datum
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Náklady na činnost na jednoho zaměstnance
 DocType: Accounts Settings,Settings for Accounts,Nastavení účtů
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +663,Supplier Invoice No exists in Purchase Invoice {0},Dodavatelské faktury No existuje ve faktuře {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +667,Supplier Invoice No exists in Purchase Invoice {0},Dodavatelské faktury No existuje ve faktuře {0}
 apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Správa obchodník strom.
 DocType: Job Applicant,Cover Letter,Průvodní dopis
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Vynikající Šeky a vklady s jasnými
 DocType: Item,Synced With Hub,Synchronizovány Hub
-DocType: Vehicle,Fleet Manager,Fleet manager
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +517,Row #{0}: {1} can not be negative for item {2},Řádek # {0}: {1} nemůže být negativní na položku {2}
+DocType: Driver,Fleet Manager,Fleet manager
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Řádek # {0}: {1} nemůže být negativní na položku {2}
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Špatné Heslo
 DocType: Item,Variant Of,Varianta
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +367,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 +387,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
 DocType: Physician,Time per Appointment,Čas na jednu schůzku
 apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Kruhové Referenční Chyba
 DocType: Appointment Type,Is Inpatient,Je hospitalizován
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Jméno Guardian1
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Jméno Guardian1
 DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"Ve slovech (export) budou viditelné, jakmile uložíte doručení poznámku."
 DocType: Cheque Print Template,Distance from left edge,Vzdálenost od levého okraje
 apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednotek [{1}] (# Form / bodu / {1}) byla nalezena v [{2}] (# Form / sklad / {2})
@@ -429,20 +454,22 @@
 DocType: BOM Item,Rate & Amount,Cena a částka
 apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Toto je založeno na transakcích proti této společnosti. Více informací naleznete v časové ose níže
 DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Upozornit e-mailem na tvorbu automatických Materiál Poptávka
-apps/erpnext/erpnext/healthcare/setup.py +258,Resistant,Odolný
+apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Odolný
 DocType: Journal Entry,Multi Currency,Více měn
-DocType: Payment Reconciliation Invoice,Invoice Type,Typ faktury
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +865,Delivery Note,Dodací list
+DocType: Opening Invoice Creation Tool,Invoice Type,Typ faktury
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +933,Delivery Note,Dodací list
 DocType: Consultation,Encounter Impression,Setkání s impresi
 apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Nastavení Daně
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +131,Cost of Sold Asset,Náklady prodaných aktiv
-apps/erpnext/erpnext/accounts/utils.py +345,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 +448,{0} entered twice in Item Tax,{0} vloženo dvakrát v Daňové Položce
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Náklady prodaných aktiv
+DocType: Volunteer,Morning,Ráno
+apps/erpnext/erpnext/accounts/utils.py +347,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 +464,{0} entered twice in Item Tax,{0} vloženo dvakrát v Daňové Položce
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Shrnutí pro tento týden a probíhajícím činnostem
 DocType: Student Applicant,Admitted,"připustil,"
 DocType: Workstation,Rent Cost,Rent Cost
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Částka po odpisech
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Nadcházející Události v kalendáři
+apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Variant atributy
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,Vyberte měsíc a rok
 DocType: Employee,Company Email,Společnost E-mail
 DocType: GL Entry,Debit Amount in Account Currency,Debetní Částka v měně účtu
@@ -451,33 +478,35 @@
 apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Banka / Hotovostní operace proti osobě nebo pro interní převod
 DocType: Shipping Rule,Valid for Countries,"Platí pro země,"
 apps/erpnext/erpnext/stock/doctype/item/item.js +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"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"""
+DocType: Grant Application,Grant Application,Žádost o grant
 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 +238,"Employee designation (e.g. CEO, Director etc.).","Označení zaměstnanců (např CEO, ředitel atd.)."
+apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Označení zaměstnanců (např CEO, ředitel atd.)."
 DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je měna zákazníka převedena na základní měnu zákazníka"
 DocType: Course Scheduling Tool,Course Scheduling Tool,Samozřejmě Plánování Tool
-apps/erpnext/erpnext/controllers/accounts_controller.py +558,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Řádek # {0}: faktury nelze provést vůči stávajícímu aktivu {1}
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Urgentní] Chyba při vytváření opakujících se% s pro% s
+apps/erpnext/erpnext/controllers/accounts_controller.py +602,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Řádek # {0}: faktury nelze provést vůči stávajícímu aktivu {1}
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Urgentní] Chyba při vytváření opakujících se %s pro %s
+DocType: Land Unit,LInked Analysis,Llnked Analysis
 DocType: Item Tax,Tax Rate,Tax Rate
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} již přidělené pro zaměstnance {1} na dobu {2} až {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +890,Select Item,Select Položka
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +915,Select Item,Select Položka
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +140,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í být stejné, jako {1} {2}"
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Převést na non-Group
-apps/erpnext/erpnext/config/stock.py +127,Batch (lot) of an Item.,Šarže položky.
 DocType: C-Form Invoice Detail,Invoice Date,Datum Fakturace
 DocType: GL Entry,Debit Amount,Debetní Částka
-apps/erpnext/erpnext/accounts/party.py +253,There can only be 1 Account per Company in {0} {1},Tam může být pouze 1 účet na společnosti v {0} {1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +407,Please see attachment,"Prosím, viz příloha"
+apps/erpnext/erpnext/accounts/party.py +251,There can only be 1 Account per Company in {0} {1},Tam může být pouze 1 účet na společnosti v {0} {1}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426,Please see attachment,"Prosím, viz příloha"
 DocType: Purchase Order,% Received,% Přijaté
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Vytvoření skupiny studentů
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +21,Setup Already Complete!!,Setup již dokončen !!
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Vytvoření skupiny studentů
+DocType: Volunteer,Weekends,Víkendy
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Částka kreditní poznámky
 DocType: Setup Progress Action,Action Document,Akční dokument
+DocType: Chapter Member,Website URL,URL webu
 ,Finished Goods,Hotové zboží
 DocType: Delivery Note,Instructions,Instrukce
 DocType: Quality Inspection,Inspected By,Zkontrolován
-DocType: Maintenance Visit,Maintenance Type,Typ Maintenance
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} není zařazen do kurzu {2}
+DocType: Asset Maintenance Log,Maintenance Type,Typ Maintenance
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} není zařazen do kurzu {2}
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Pořadové číslo {0} není součástí dodávky Poznámka: {1}
 apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
 apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Přidat položky
@@ -488,31 +517,33 @@
 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 pro zaměstnance {0} proti Typ aktivity - {1}
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Povinná pole - Získajte studenty z
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Povinná pole - Získajte studenty z
 DocType: Program Enrollment,Enrolled courses,Zapsané kurzy
 DocType: Currency Exchange,Currency Exchange,Směnárna
-DocType: Asset,Item Name,Název položky
+DocType: Opening Invoice Creation Tool Item,Item Name,Název položky
 DocType: Authorization Rule,Approving User  (above authorized value),Schválení uživatele (nad oprávněné hodnoty)
 DocType: Email Digest,Credit Balance,Credit Balance
 DocType: Employee,Widowed,Ovdovělý
 DocType: Request for Quotation,Request for Quotation,Žádost o cenovou nabídku
 DocType: Healthcare Settings,Require Lab Test Approval,Požadovat schválení testu laboratoře
 DocType: Salary Slip Timesheet,Working Hours,Pracovní doba
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Naprosto vynikající
 DocType: Naming Series,Change the starting / current sequence number of an existing series.,Změnit výchozí / aktuální pořadové číslo existujícího série.
 DocType: Dosage Strength,Strength,Síla
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1508,Create a new Customer,Vytvořit nový zákazník
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1523,Create a new Customer,Vytvořit nový zákazník
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Je-li více pravidla pro tvorbu cen i nadále přednost, jsou uživatelé vyzváni k nastavení priority pro vyřešení konfliktu."
 apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Vytvoření objednávek
 ,Purchase Register,Nákup Register
-DocType: Course Scheduling Tool,Rechedule,Rechedule
+DocType: Scheduling Tool,Rechedule,Rechedule
 DocType: Landed Cost Item,Applicable Charges,Použitelné Poplatky
 DocType: Workstation,Consumable Cost,Spotřební Cost
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',"{0} ({1}), musí mít roli ""Schvalovatel dovolených"""
 DocType: Purchase Receipt,Vehicle Date,Datum Vehicle
 DocType: Student Log,Medical,Lékařský
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Důvod ztráty
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +41,Lead Owner cannot be same as the Lead,Olovo Majitel nemůže být stejný jako olovo
-apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not greater than unadjusted amount,Přidělená částka nemůže větší než množství neupravené
+apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Aktualizovat číslo účtu
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Olovo Majitel nemůže být stejný jako olovo
+apps/erpnext/erpnext/accounts/utils.py +353,Allocated amount can not greater than unadjusted amount,Přidělená částka nemůže větší než množství neupravené
 DocType: Announcement,Receiver,Přijímač
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,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,Příležitosti
@@ -528,7 +559,7 @@
 DocType: Lab Test Template,No Result,Žádný výsledek
 DocType: Purchase Invoice Item,Quantity and Rate,Množství a cena
 DocType: Delivery Note,% Installed,% Instalováno
-apps/erpnext/erpnext/utilities/user_progress.py +209,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učebny / etc laboratoře, kde mohou být naplánovány přednášky."
+apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učebny / etc laboratoře, kde mohou být naplánovány přednášky."
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,"Prosím, zadejte nejprve název společnosti"
 DocType: Purchase Invoice,Supplier Name,Dodavatel Name
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Přečtěte si ERPNext Manuál
@@ -536,40 +567,45 @@
 DocType: Email Digest,Pending Purchase Orders,Čeká objednávek
 DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automaticky nastavit sériových čísel na základě FIFO
 DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,"Zkontrolujte, zda dodavatelské faktury Počet Jedinečnost"
+apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Údaje o primární adrese
 DocType: Vehicle Service,Oil Change,Výměna oleje
+DocType: Asset Maintenance Log,Asset Maintenance Log,Protokol o údržbě aktiv
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',"""DO Případu č.' nesmí být menší než ""Od Případu č.'"
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +142,Non Profit,Non Profit
+DocType: Chapter,Non Profit,Non Profit
 DocType: Production Order,Not Started,Nezahájeno
 DocType: Lead,Channel Partner,Channel Partner
 DocType: Account,Old Parent,Staré nadřazené
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Povinná oblast - Akademický rok
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Povinná oblast - Akademický rok
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} is not associated with {2} {3},{0} {1} není přidružen k {2} {3}
 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."
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +157,Please set default payable account for the company {0},Nastavte prosím výchozí splatný účet společnosti {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +182,Please set default payable account for the company {0},Nastavte prosím výchozí splatný účet společnosti {0}
 DocType: Setup Progress Action,Min Doc Count,Minimální počet dokumentů
 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 +685,Attribute {0} selected multiple times in Attributes Table,Atribut {0} vybraný několikrát v atributech tabulce
+apps/erpnext/erpnext/stock/doctype/item/item.py +671,Attribute {0} selected multiple times in Attributes Table,Atribut {0} vybraný několikrát v atributech tabulce
 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.
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +77,Opening Invoice Item,Otevření položky faktury
 DocType: Request for Quotation Item,Required Date,Požadovaná data
 DocType: Delivery Note,Billing Address,Fakturační adresa
 DocType: BOM,Costing,Rozpočet
 DocType: Tax Rule,Billing County,fakturace County
 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,Zpráva pro dodavatele
+DocType: Driver,DRIVER-.#####,ŘIDIČ-.#####
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Celkem Množství
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,ID e-mailu Guardian2
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,ID e-mailu Guardian2
 DocType: Item,Show in Website (Variant),Show do webových stránek (Variant)
 DocType: Employee,Health Concerns,Zdravotní Obavy
-DocType: Process Payroll,Select Payroll Period,Vyberte mzdové
+DocType: Payroll Entry,Select Payroll Period,Vyberte mzdové
 DocType: Purchase Invoice,Unpaid,Nezaplacený
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Vyhrazeno pro prodej
 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
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +44,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Metoda oceňování nelze změnit, neboť existují transakce proti některým položkám, které nemají vlastní metodu oceňování"
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Metoda oceňování nelze změnit, neboť existují transakce proti některým položkám, které nemají vlastní metodu oceňování"
 apps/erpnext/erpnext/config/healthcare.py +133,Test Sample Master.,Testovací vzorek Master.
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Celkem listy přidělené je povinné
 DocType: Patient,AB Positive,AB pozitivní
@@ -591,35 +627,39 @@
 DocType: Training Event,Workshop,Dílna
 DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Upozornění na nákupní objednávky
 apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Seznam několik svých zákazníků. Ty by mohly být organizace nebo jednotlivci.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Dodavatel&gt; Typ dodavatele
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +21,Enough Parts to Build,Dost Části vybudovat
 DocType: POS Profile User,POS Profile User,Uživatel profilu POS
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Přímý příjmů
 DocType: Patient Appointment,Date TIme,Čas schůzky
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"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 +126,Administrative Officer,Správní ředitel
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +22,Please select Course,Vyberte možnost Kurz
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,Správní ředitel
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Založení společnosti a daně
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Vyberte možnost Kurz
 DocType: Codification Table,Codification Table,Kodifikační tabulka
 DocType: Timesheet Detail,Hrs,hod
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +342,Please select Company,"Prosím, vyberte Company"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +350,Please select Company,"Prosím, vyberte Company"
 DocType: Stock Entry Detail,Difference Account,Rozdíl účtu
 DocType: Purchase Invoice,Supplier GSTIN,Dodavatel GSTIN
 apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,"Nelze zavřít úkol, jak jeho závislý úkol {0} není uzavřen."
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +433,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
 DocType: Lab Test Template,Lab Routine,Lab Rutine
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,Kosmetika
-apps/erpnext/erpnext/stock/doctype/item/item.py +545,"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/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Kosmetika
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Zvolte datum dokončení dokončeného protokolu údržby aktiv
+apps/erpnext/erpnext/stock/doctype/item/item.py +526,"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
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Koupit
 ,Serial No Warranty Expiry,Pořadové č záruční lhůty
 DocType: Sales Invoice,Offline POS Name,Offline POS Name
-apps/erpnext/erpnext/utilities/user_progress.py +159,Student Application,Studentská aplikace
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Zadejte prosím stupeň pro Threshold 0%
+apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Studentská aplikace
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Zadejte prosím stupeň pro Threshold 0%
 DocType: Sales Order,To Deliver,Dodat
 DocType: Purchase Invoice Item,Item,Položka
-apps/erpnext/erpnext/healthcare/setup.py +255,High Sensitivity,Vysoká citlivost
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2493,Serial no item cannot be a fraction,Sériové žádná položka nemůže být zlomkem
+apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Vysoká citlivost
+apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Informace o typu dobrovolníka.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2512,Serial no item cannot be a fraction,Sériové žádná položka nemůže být zlomkem
 DocType: Journal Entry,Difference (Dr - Cr),Rozdíl (Dr - Cr)
 DocType: Account,Profit and Loss,Zisky a ztráty
 DocType: Patient,Risk Factors,Rizikové faktory
@@ -628,6 +668,7 @@
 apps/erpnext/erpnext/config/stock.py +330,Managing Subcontracting,Správa Subdodávky
 DocType: Vital Signs,Body Temperature,Tělesná teplota
 DocType: Project,Project will be accessible on the website to these users,Projekt bude k dispozici na webových stránkách k těmto uživatelům
+DocType: Detected Disease,Disease,Choroba
 apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Definujte typ projektu.
 DocType: Supplier Scorecard,Weighting Function,Funkce vážení
 DocType: Physician,OP Consulting Charge,Konzultační poplatek OP
@@ -636,27 +677,29 @@
 apps/erpnext/erpnext/setup/doctype/company/company.py +62,Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1}
 apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Zkratka již byla použita pro jinou společnost
 DocType: Selling Settings,Default Customer Group,Výchozí Customer Group
+DocType: Asset Repair,ARLOG-,ARLOG-
 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: Crop,Produced Items,Vyrobené položky
 DocType: Sales Order Item,Gross Profit,Hrubý Zisk
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Přírůstek nemůže být 0
 DocType: Production Planning Tool,Material Requirement,Požadavek materiálu
 DocType: Company,Delete Company Transactions,Smazat transakcí Company
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +350,Reference No and Reference Date is mandatory for Bank transaction,Referenční číslo a referenční datum je povinný pro bankovní transakce
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,Reference No and Reference Date is mandatory for Bank transaction,Referenční číslo a referenční datum je povinný pro bankovní transakce
 DocType: Purchase Receipt,Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatků
 DocType: Payment Entry Reference,Supplier Invoice No,Dodavatelské faktury č
 DocType: Territory,For reference,Pro srovnání
 DocType: Healthcare Settings,Appointment Confirmation,Potvrzení jmenování
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Nelze odstranit Pořadové číslo {0}, který se používá na skladě transakcích"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Cr),Uzavření (Cr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +253,Closing (Cr),Uzavření (Cr)
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Ahoj
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +110,Move Item,Přemístit položku
 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,Čekající Množství
 DocType: Budget,Ignore,Ignorovat
-apps/erpnext/erpnext/accounts/party.py +372,{0} {1} is not active,{0} {1} není aktivní
-apps/erpnext/erpnext/config/accounts.py +285,Setup cheque dimensions for printing,Zkontrolujte nastavení rozměry pro tisk
+apps/erpnext/erpnext/accounts/party.py +384,{0} {1} is not active,{0} {1} není aktivní
+apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Zkontrolujte nastavení rozměry pro tisk
 DocType: Salary Slip,Salary Slip Timesheet,Plat Slip časový rozvrh
 apps/erpnext/erpnext/controllers/buying_controller.py +157,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení
 DocType: Pricing Rule,Valid From,Platnost od
@@ -664,19 +707,21 @@
 DocType: Pricing Rule,Sales Partner,Sales Partner
 apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Všechna hodnocení dodavatelů.
 DocType: Buying Settings,Purchase Receipt Required,Příjmka je vyžadována
-apps/erpnext/erpnext/stock/doctype/item/item.py +142,Valuation Rate is mandatory if Opening Stock entered,"Cena je povinná, pokud je zadán počáteční stav zásob"
+apps/erpnext/erpnext/stock/doctype/item/item.py +144,Valuation Rate is mandatory if Opening Stock entered,"Cena je povinná, pokud je zadán počáteční stav zásob"
 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 +17,Please select Company and Party Type first,Vyberte první společnost a Party Typ
-apps/erpnext/erpnext/config/accounts.py +301,Financial / accounting year.,Finanční / Účetní rok.
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default",Již nastavený výchozí profil {0} pro uživatele {1} je laskavě vypnut výchozí
+apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Finanční / Účetní rok.
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Neuhrazená Hodnoty
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit"
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +63,Territory is Required in POS Profile,Území je vyžadováno v POS profilu
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +68,Territory is Required in POS Profile,Území je vyžadováno v POS profilu
 DocType: Supplier,Prevent RFQs,Zabraňte RFQ
 apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Ujistěte se prodejní objednávky
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Zápis o platu odeslán na období od {0} do {1}
 DocType: Project Task,Project Task,Úkol Project
 ,Lead Id,Id leadu
 DocType: C-Form Invoice Detail,Grand Total,Celkem
-DocType: Training Event,Course,Chod
+DocType: Assessment Plan,Course,Chod
 DocType: Timesheet,Payslip,výplatní páska
 apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Item košík
 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í
@@ -689,7 +734,9 @@
 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
 DocType: Leave Control Panel,Allocate,Přidělit
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +804,Sales Return,Sales Return
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Vytvořte variantu
+DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Otevření nástroje pro vytváření faktur
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +851,Sales Return,Sales Return
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Poznámka: Celkový počet alokovaných listy {0} by neměla být menší než které již byly schváleny listy {1} pro období
 ,Total Stock Summary,Shrnutí souhrnného stavu
 DocType: Announcement,Posted By,Přidal
@@ -700,40 +747,45 @@
 apps/erpnext/erpnext/config/selling.py +28,Customer database.,Databáze zákazníků.
 DocType: Quotation,Quotation To,Nabídka k
 DocType: Lead,Middle Income,Středními příjmy
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Cr),Otvor (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +849,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Výchozí měrná jednotka bodu {0} nemůže být změněna přímo, protože jste už nějaké transakce (y) s jiným nerozpuštěných. Budete muset vytvořit novou položku použít jiný výchozí UOM."
-apps/erpnext/erpnext/accounts/utils.py +349,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 +225,Opening (Cr),Otvor (Cr)
+apps/erpnext/erpnext/stock/doctype/item/item.py +835,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Výchozí měrná jednotka bodu {0} nemůže být změněna přímo, protože jste už nějaké transakce (y) s jiným nerozpuštěných. Budete muset vytvořit novou položku použít jiný výchozí UOM."
+apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not be negative,Přidělená částka nemůže být záporná
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Nastavte společnost
 DocType: Purchase Order Item,Billed Amt,Účtovaného Amt
 DocType: Training Result Employee,Training Result Employee,Vzdělávací Výsledek
 DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny."
 DocType: Repayment Schedule,Principal Amount,jistina
 DocType: Employee Loan Application,Total Payable Interest,Celkem Splatné úroky
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +59,Total Outstanding: {0},Celková nevyřízená hodnota: {0}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Celková nevyřízená hodnota: {0}
 DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Prodejní faktury časový rozvrh
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0}
-DocType: Process Payroll,Select Payment Account to make Bank Entry,"Vybrat Platební účet, aby Bank Entry"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0}
+DocType: Payroll Entry,Select Payment Account to make Bank Entry,"Vybrat Platební účet, aby Bank Entry"
 apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Vytvořit Zaměstnanecké záznamy pro správu listy, prohlášení o výdajích a mezd"
 apps/erpnext/erpnext/config/healthcare.py +118,Prescription Period,Předepsaná doba
 DocType: Restaurant Reservation,Restaurant Reservation,Rezervace restaurace
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +186,Proposal Writing,Návrh Psaní
+DocType: Land Unit,Land Unit Name,Název půdní jednotky
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Návrh Psaní
 DocType: Payment Entry Deduction,Payment Entry Deduction,Platba Vstup dedukce
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Obalte se
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Informujte zákazníky e-mailem
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Další prodeje osoba {0} existuje se stejným id zaměstnance
+DocType: Employee Advance,Claimed Amount,Požadovaná částka
 DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Je-li zaškrtnuto, suroviny pro položky, které jsou subdodavatelsky budou zahrnuty v materiálu Žádosti"
 apps/erpnext/erpnext/config/healthcare.py +61,Masters,Masters
 DocType: Assessment Plan,Maximum Assessment Score,Maximální skóre Assessment
-apps/erpnext/erpnext/config/accounts.py +146,Update Bank Transaction Dates,Transakční Data aktualizace Bank
+apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Transakční Data aktualizace Bank
 apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Time Tracking
 DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLIKÁT PRO TRANSPORTER
+apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,Řádek {0} # Placená částka nesmí být vyšší než požadovaná částka
 DocType: Fiscal Year Company,Fiscal Year Company,Fiskální rok Společnosti
 DocType: Packing Slip Item,DN Detail,DN Detail
 DocType: Training Event,Conference,Konference
 DocType: Timesheet,Billed,Fakturováno
 DocType: Batch,Batch Description,Popis Šarže
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Vytváření studentských skupin
-apps/erpnext/erpnext/accounts/utils.py +721,"Payment Gateway Account not created, please create one manually.","Platební brána účet nevytvořili, prosím, vytvořte ručně."
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Vytváření studentských skupin
+apps/erpnext/erpnext/accounts/utils.py +724,"Payment Gateway Account not created, please create one manually.","Platební brána účet nevytvořili, prosím, vytvořte ručně."
 DocType: Supplier Scorecard,Per Year,Za rok
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Není způsobilý pro přijetí do tohoto programu podle DOB
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Není způsobilý pro přijetí do tohoto programu podle DOB
 DocType: Sales Invoice,Sales Taxes and Charges,Prodej Daně a poplatky
 DocType: Employee,Organization Profile,Profil organizace
 DocType: Vital Signs,Height (In Meter),Výška (v metru)
@@ -741,25 +793,25 @@
 DocType: Vehicle Service,Vehicle Service,servis vozidel
 apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Automaticky spouští žádost o zpětné vazby založené na podmínkách.
 DocType: Employee,Reason for Resignation,Důvod rezignace
-apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Šablona pro hodnocení výkonu.
+apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Šablona pro hodnocení výkonu.
 DocType: Sales Invoice,Credit Note Issued,Dobropisu vystaveného
 DocType: Project Task,Weight,Hmotnost
 DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti
 apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} '{1}' není v fiskálním roce {2}
 DocType: Buying Settings,Settings for Buying Module,Nastavení pro nákup modul
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Aktiva {0} nepatří do společnosti {1}
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Aktiva {0} nepatří do společnosti {1}
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,"Prosím, zadejte první doklad o zakoupení"
 DocType: Buying Settings,Supplier Naming By,Dodavatel Pojmenování By
 DocType: Activity Type,Default Costing Rate,Výchozí kalkulace Rate
 DocType: Maintenance Schedule,Maintenance Schedule,Plán údržby
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","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 +24,Net Change in Inventory,Čistá Změna stavu zásob
-apps/erpnext/erpnext/config/hr.py +157,Employee Loan Management,Zaměstnanec úvěru Vedení
+apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Zaměstnanec úvěru Vedení
 DocType: Employee,Passport Number,Číslo pasu
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Souvislost s Guardian2
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +120,Manager,Manažer
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Souvislost s Guardian2
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Manažer
 DocType: Payment Entry,Payment From / To,Platba z / do
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +127,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nový úvěrový limit je nižší než aktuální dlužné částky za zákazníka. Úvěrový limit musí být aspoň {0}
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +155,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nový úvěrový limit je nižší než aktuální dlužné částky za zákazníka. Úvěrový limit musí být aspoň {0}
 apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""Založeno na"" a ""Seskupeno podle"", nemůže být stejné"
 DocType: Sales Person,Sales Person Targets,Obchodník cíle
 DocType: Installation Note,IN-,V-
@@ -768,43 +820,46 @@
 DocType: Lab Test Template,Compound,Sloučenina
 DocType: Student Batch Name,Batch Name,Batch Name
 DocType: Fee Validity,Max number of visit,Maximální počet návštěv
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +319,Timesheet created:,Časového rozvrhu vytvoření:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +908,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/schools/doctype/student_applicant/student_applicant.js +24,Enroll,Zapsat
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Časového rozvrhu vytvoření:
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +920,Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0}
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,Zapsat
 DocType: GST Settings,GST Settings,Nastavení GST
 DocType: Selling Settings,Customer Naming By,Zákazník Pojmenování By
 DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Ukáže studenta přítomnému v Student měsíční návštěvnost Zpráva
 DocType: Depreciation Schedule,Depreciation Amount,odpisy Částka
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Převést do skupiny
+DocType: Delivery Trip,TOUR-.#####,PROHLÍDKA-.#####
 DocType: Activity Cost,Activity Type,Druh činnosti
 DocType: Request for Quotation,For individual supplier,Pro jednotlivé dodavatele
 DocType: BOM Operation,Base Hour Rate(Company Currency),Základna hodinová sazba (Company měny)
 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é Dny
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests,Laboratorní testy
+DocType: Company,Fixed Days,Pevné Dny
 DocType: Quotation Item,Item Balance,Balance položka
 DocType: Sales Invoice,Packing List,Balící list
 apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Nákupní Objednávky odeslané Dodavatelům.
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,Publikování
+apps/erpnext/erpnext/setup/setup_wizard/data/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 +157,{0}: {1} not found in Invoice Details table,{0}: {1} nebyla nalezena v tabulce Podrobnosti Faktury
+DocType: Asset,Asset Owner Company,Společnost vlastníků aktiv
 DocType: Company,Round Off Cost Center,Zaokrouhlovací nákladové středisko
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +227,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 +242,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: Asset Maintenance Log,AML-,AML-
 DocType: Item,Material Transfer,Přesun materiálu
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Nelze najít cestu pro
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +211,Opening (Dr),Opening (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,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}
 apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Provádět opakované dokumenty
 ,GST Itemised Purchase Register,GST Itemised Purchase Register
+DocType: Course Scheduling Tool,Reschedule,Změna plánu
 DocType: Employee Loan,Total Interest Payable,Celkem splatných úroků
 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,Čas operace
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +293,Finish,Dokončit
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +395,Base,Báze
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +315,Finish,Dokončit
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Báze
 DocType: Timesheet,Total Billed Hours,Celkem Předepsané Hodiny
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1351,Write Off Amount,Odepsat Částka
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1438,Write Off Amount,Odepsat Částka
 DocType: Leave Block List Allow,Allow User,Umožňuje uživateli
 DocType: Journal Entry,Bill No,Bill No
 DocType: Company,Gain/Loss Account on Asset Disposal,Zisk / ztráty na majetku likvidaci
@@ -818,33 +873,38 @@
 DocType: Student Attendance,Student Attendance,Student Účast
 DocType: Sales Invoice Timesheet,Time Sheet,Rozvrh hodin
 DocType: Manufacturing Settings,Backflush Raw Materials Based On,Se zpětným suroviny na základě
-DocType: Interest,Interest,Zajímat
+DocType: Lead,Lead is an Organization,Vedoucí je organizace
+DocType: Guardian Interest,Interest,Zajímat
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Předprodej
 DocType: Purchase Receipt,Other Details,Další podrobnosti
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
 DocType: Lab Test,Test Template,Testovací šablona
 DocType: Restaurant Order Entry Item,Served,Podával
+apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Informace o kapitole.
 DocType: Account,Accounts,Účty
 DocType: Vehicle,Odometer Value (Last),Údaj měřiče ujeté vzdálenosti (Last)
 apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Šablony kritérií kritérií pro dodavatele.
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +105,Marketing,Marketing
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Marketing
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,Vstup Platba je již vytvořili
 DocType: Request for Quotation,Get Suppliers,Získejte dodavatele
 DocType: Purchase Receipt Item Supplied,Current Stock,Current skladem
-apps/erpnext/erpnext/controllers/accounts_controller.py +545,Row #{0}: Asset {1} does not linked to Item {2},Řádek # {0}: Asset {1} není spojena s item {2}
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +377,Preview Salary Slip,Preview výplatní pásce
+apps/erpnext/erpnext/controllers/accounts_controller.py +589,Row #{0}: Asset {1} does not linked to Item {2},Řádek # {0}: Asset {1} není spojena s item {2}
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Preview výplatní pásce
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Účet {0} byl zadán vícekrát
 DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
+apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +23,You can only renew if your membership expires within 30 days,"Můžete obnovit pouze tehdy, pokud vaše členství vyprší během 30 dnů"
+DocType: Land Unit,Longitude,Zeměpisná délka
 ,Absent Student Report,Absent Student Report
+DocType: Crop,Crop Spacing UOM,Rozdělení výsevních ploch UOM
 DocType: Email Digest,Next email will be sent on:,Další e-mail bude odeslán dne:
 DocType: Offer Letter Term,Offer Letter Term,Nabídka Letter Term
 DocType: Supplier Scorecard,Per Week,Za týden
-apps/erpnext/erpnext/stock/doctype/item/item.py +658,Item has variants.,Položka má varianty.
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Celkový počet studentů
+apps/erpnext/erpnext/stock/doctype/item/item.py +639,Item has variants.,Položka má varianty.
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Celkový počet studentů
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Položka {0} nebyl nalezen
 DocType: Bin,Stock Value,Reklamní Value
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +41,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,V pozadí budou vytvořeny záznamy o poplatcích. V případě jakékoliv chyby bude chybová zpráva aktualizována v rozvrhu.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +26,Company {0} does not exist,Společnost {0} neexistuje
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,V pozadí budou vytvořeny záznamy o poplatcích. V případě jakékoliv chyby bude chybová zpráva aktualizována v rozvrhu.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +241,Company {0} does not exist,Společnost {0} neexistuje
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} má platnost až do {1}
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Tree Type
 DocType: BOM Explosion Item,Qty Consumed Per Unit,Množství spotřebované na jednotku
@@ -852,42 +912,46 @@
 DocType: Material Request Item,Quantity and Warehouse,Množství a sklad
 DocType: Hub Settings,Unregister,Zrušit registraci
 DocType: Sales Invoice,Commission Rate (%),Výše provize (%)
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +24,Please select Program,Vyberte prosím Program
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Vyberte prosím Program
 DocType: Project,Estimated Cost,Odhadované náklady
 DocType: Purchase Order,Link to material requests,Odkaz na materiálních požadavků
 DocType: Hub Settings,Publish,Publikovat
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Aerospace
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Aerospace
 DocType: Journal Entry,Credit Card Entry,Vstup Kreditní karta
 apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Společnost a účty
 apps/erpnext/erpnext/config/healthcare.py +108,Appointment Type Master,Typ schůzky Master
-apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Zboží od dodavatelů.
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +58,In Value,v Hodnota
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,v Hodnota
 DocType: Lead,Campaign Name,Název kampaně
 DocType: Selling Settings,Close Opportunity After Days,V blízkosti Příležitost po několika dnech
 ,Reserved,Rezervováno
+DocType: Driver,License Details,Podrobnosti licence
 DocType: Purchase Order,Supply Raw Materials,Dodávek surovin
 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 +94,{0} is not a stock Item,{0} není skladová položka
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,{0} is not a stock Item,{0} není skladová položka
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Podělte se o své připomínky k tréninku kliknutím na &quot;Tréninkové připomínky&quot; a poté na &quot;Nové&quot;
 DocType: Mode of Payment Account,Default Account,Výchozí účet
+apps/erpnext/erpnext/stock/doctype/item/item.py +262,Please select Sample Retention Warehouse in Stock Settings first,Zvolte prosím nejprve Sample Retention Warehouse in Stock Stock
 DocType: Payment Entry,Received Amount (Company Currency),Přijaté Částka (Company měna)
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,Lead musí být nastaven pokud je Příležitost vyrobena z leadu
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,"Prosím, vyberte týdenní off den"
 DocType: Patient,O Negative,O Negativní
 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 +96,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 +95,Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu
+apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Podrobnosti o typu člena
 DocType: Delivery Note,Customer's Purchase Order No,Zákazníka Objednávka No
 DocType: Budget,Budget Against,rozpočet Proti
 DocType: Employee,Cell Number,Číslo buňky
-apps/erpnext/erpnext/stock/reorder_item.py +177,Auto Material Requests Generated,Žádosti Auto materiál vygenerovaný
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,"Pro daná kritéria neexistuje žádný zaměstnanec. Zkontrolujte, zda nebyly dosud vytvořeny platové kursy."
+apps/erpnext/erpnext/stock/reorder_item.py +190,Auto Material Requests Generated,Žádosti 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 +152,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/accounts/doctype/journal_entry/journal_entry.py +150,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/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Vyhrazeno pro výrobu
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,Energie
+DocType: Soil Texture,Sand,Písek
+apps/erpnext/erpnext/setup/setup_wizard/data/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í.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +876,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Řádek {0}: {1} Sériová čísla vyžadovaná pro položku {2}. Poskytli jste {3}.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +881,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Řádek {0}: {1} Sériová čísla vyžadovaná pro položku {2}. Poskytli jste {3}.
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Vyberte prosím tabulku
 DocType: BOM,Website Specifications,Webových stránek Specifikace
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} je neplatná e-mailová adresa v adresáři &quot;Příjemci&quot;
@@ -895,12 +959,14 @@
 apps/erpnext/erpnext/config/healthcare.py +143,Antibiotic.,Antibiotikum.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Od {0} typu {1}
 DocType: Warranty Claim,CI-,Ci
-apps/erpnext/erpnext/controllers/buying_controller.py +291,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
-DocType: Employee,A+,A+
+apps/erpnext/erpnext/controllers/buying_controller.py +292,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
+DocType: Student,A+,A+
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +326,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Více Cena pravidla existuje u stejných kritérií, prosím vyřešit konflikt tím, že přiřadí prioritu. Cena Pravidla: {0}"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +501,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/manufacturing/doctype/bom/bom.py +504,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: Asset,Maintenance,Údržba
 DocType: Item Attribute Value,Item Attribute Value,Položka Hodnota atributu
+DocType: Item,Maximum sample quantity that can be retained,"Maximální množství vzorku, které lze zadržet"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +393,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Řádek {0} # Položka {1} nelze převést více než {2} na objednávku {3}
 apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Prodej kampaně.
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,Udělat TimeSheet
 DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
@@ -950,21 +1016,25 @@
 DocType: Expense Claim Detail,Expense Claim Type,Náklady na pojistná Type
 DocType: Shopping Cart Settings,Default settings for Shopping Cart,Výchozí nastavení Košík
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Přidat Timeslots
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset vyhozen přes položka deníku {0}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset vyhozen přes položka deníku {0}
 DocType: Employee Loan,Interest Income Account,Účet Úrokové výnosy
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Biotechnologie
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Prohlížení pozvánky odesláno
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Biotechnologie
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Náklady Office údržby
 apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Jít do
 apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Nastavení e-mailový účet
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,"Prosím, nejdřív zadejte položku"
+DocType: Asset Repair,Downtime,Nefunkčnost
 DocType: Account,Liability,Odpovědnost
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionována Částka nemůže být větší než reklamace Částka v řádku {0}.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +234,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionována Částka nemůže být větší než reklamace Částka v řádku {0}.
 DocType: Salary Detail,Do not include in total,Nezahrnujte celkem
 DocType: Company,Default Cost of Goods Sold Account,Výchozí Náklady na prodané zboží účtu
-apps/erpnext/erpnext/stock/get_item_details.py +319,Price List not selected,Ceník není zvolen
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +964,Sample quantity {0} cannot be more than received quantity {1},Množství vzorku {0} nemůže být větší než přijaté množství {1}
+apps/erpnext/erpnext/stock/get_item_details.py +362,Price List not selected,Ceník není zvolen
 DocType: Employee,Family Background,Rodinné poměry
 DocType: Request for Quotation Supplier,Send Email,Odeslat email
-apps/erpnext/erpnext/stock/doctype/item/item.py +216,Warning: Invalid Attachment {0},Varování: Neplatná Příloha {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +218,Warning: Invalid Attachment {0},Varování: Neplatná Příloha {0}
+DocType: Item,Max Sample Quantity,Max. Množství vzorku
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +764,No Permission,Nemáte oprávnění
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +438,Quote Requested,Požadovaná citace
 DocType: Vital Signs,Heart Rate / Pulse,Srdeční frekvence / puls
@@ -972,32 +1042,34 @@
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +50,"To filter based on Party, select Party Type first","Chcete-li filtrovat na základě Party, vyberte typ Party první"
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"""Aktualizovat sklad' nemůže být zaškrtnuto, protože položky nejsou dodány přes {0}"
 DocType: Vehicle,Acquisition Date,akvizice Datum
-apps/erpnext/erpnext/utilities/user_progress.py +125,Nos,Nos
+apps/erpnext/erpnext/utilities/user_progress.py +143,Nos,Nos
 DocType: Item,Items with higher weightage will be shown higher,Položky s vyšším weightage budou zobrazeny vyšší
+apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Laboratorní testy a vitální znaky
 DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Odsouhlasení Detail
-apps/erpnext/erpnext/controllers/accounts_controller.py +549,Row #{0}: Asset {1} must be submitted,Řádek # {0}: {1} Asset musí být předloženy
+apps/erpnext/erpnext/controllers/accounts_controller.py +593,Row #{0}: Asset {1} must be submitted,Řádek # {0}: {1} Asset musí být předloženy
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Žádný zaměstnanec nalezeno
 DocType: Subscription,Stopped,Zastaveno
 DocType: Item,If subcontracted to a vendor,Pokud se subdodávky na dodavatele
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentská skupina je již aktualizována.
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Studentská skupina je již aktualizována.
 DocType: SMS Center,All Customer Contact,Vše Kontakt Zákazník
-apps/erpnext/erpnext/config/stock.py +158,Upload stock balance via csv.,Nahrát nutnosti rovnováhy prostřednictvím CSV.
-DocType: Warehouse,Tree Details,Tree Podrobnosti
+DocType: Land Unit,Tree Details,Tree Podrobnosti
 DocType: Training Event,Event Status,Event Status
+DocType: Volunteer,Availability Timeslot,Dostupnost Timeslot
 ,Support Analytics,Podpora Analytics
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Pokud máte jakékoliv dotazy, prosím, dostat zpátky k nám."
 DocType: Item,Website Warehouse,Sklad pro web
 DocType: Payment Reconciliation,Minimum Invoice Amount,Minimální částka faktury
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: náklady Center {2} nepatří do společnosti {3}
+apps/erpnext/erpnext/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Nahrajte své písmeno hlava (Udržujte web přátelský jako 900 x 100 pixelů)
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Účet {2} nemůže být skupina
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Položka Row {idx}: {typ_dokumentu} {} DOCNAME neexistuje v předchozím &#39;{typ_dokumentu}&#39; tabulka
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +289,Timesheet {0} is already completed or cancelled,Časového rozvrhu {0} je již dokončena nebo zrušena
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +291,Timesheet {0} is already completed or cancelled,Časového rozvrhu {0} je již dokončena nebo zrušena
 apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,žádné úkoly
 DocType: Item Variant Settings,Copy Fields to Variant,Kopírování polí na variantu
 DocType: Asset,Opening Accumulated Depreciation,Otevření Oprávky
 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
 DocType: Program Enrollment Tool,Program Enrollment Tool,Program Tool zápis
-apps/erpnext/erpnext/config/accounts.py +343,C-Form records,C-Form záznamy
+apps/erpnext/erpnext/config/accounts.py +335,C-Form records,C-Form záznamy
 apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Zákazník a Dodavatel
 DocType: Email Digest,Email Digest Settings,Nastavení e-mailu Digest
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +354,Thank you for your business!,Děkuji za Váš obchod!
@@ -1008,43 +1080,48 @@
 DocType: HR Settings,Retirement Age,Duchodovy vek
 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 +372,{0} against Bill {1} dated {2},{0} proti účtence {1} ze dne {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +370,{0} against Bill {1} dated {2},{0} proti účtence {1} ze dne {2}
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Instalační instituce
 DocType: Program Enrollment,Vehicle/Bus Number,Číslo vozidla / autobusu
-apps/erpnext/erpnext/schools/doctype/course/course.js +17,Course Schedule,rozvrh
+apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,rozvrh
 DocType: Request for Quotation Supplier,Quote Status,Citace Stav
 DocType: Maintenance Visit,Completion Status,Dokončení Status
 DocType: HR Settings,Enter retirement age in years,Zadejte věk odchodu do důchodu v letech
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +252,Target Warehouse,Target Warehouse
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +118,Please select a warehouse,Vyberte prosím sklad
+DocType: Crop,Target Warehouse,Target Warehouse
+DocType: Payroll Employee Detail,Payroll Employee Detail,Zaměstnanecký detail zaměstnanců
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,Vyberte prosím sklad
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Prosím, nastavte číselnou sérii pro Účast přes Nastavení&gt; Číslovací série"
 DocType: Cheque Print Template,Starting location from left edge,Počínaje umístění od levého okraje
 DocType: Item,Allow over delivery or receipt upto this percent,Nechte přes dodávku nebo příjem aľ tohoto procenta
 DocType: Stock Entry,STE-,STE-
 DocType: Upload Attendance,Import Attendance,Importovat Docházku
 apps/erpnext/erpnext/public/js/pos/pos.html +113,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 +39,Net Profit / Loss,Čistý zisk / ztráta
 apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Automaticky napsat vzkaz na předkládání transakcí.
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte prosím jmenovací řadu pro {0} přes Nastavení&gt; Nastavení&gt; Pojmenování
 DocType: Production Order,Item To Manufacture,Položka k výrobě
 apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} je stav {2}
+DocType: Water Analysis,Collection Temperature ,Teplota sběru
 DocType: Employee,Provide Email Address registered in company,Poskytnout e-mailovou adresu registrovanou ve firmě
 DocType: Shopping Cart Settings,Enable Checkout,Aktivovat Checkout
 apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Objednávka na platební
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Předpokládané množství
 DocType: Sales Invoice,Payment Due Date,Splatno dne
 DocType: Drug Prescription,Interval UOM,Interval UOM
-apps/erpnext/erpnext/stock/doctype/item/item.js +363,Item Variant {0} already exists with same attributes,Bod Variant {0} již existuje se stejnými vlastnostmi
+apps/erpnext/erpnext/stock/doctype/item/item.js +489,Item Variant {0} already exists with same attributes,Bod Variant {0} již existuje se stejnými vlastnostmi
 DocType: Item,Hub Publishing Details,Podrobnosti o publikování Hubu
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening',&quot;Otevření&quot;
+apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening',"""Otevírací"""
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Otevřená dělat
 DocType: Notification Control,Delivery Note Message,Delivery Note Message
 DocType: Lab Test Template,Result Format,Formát výsledků
 DocType: Expense Claim,Expenses,Výdaje
+DocType: Delivery Stop,Delivery Notes,Dodací listy
 DocType: Item Variant Attribute,Item Variant Attribute,Položka Variant Atribut
 ,Purchase Receipt Trends,Doklad o koupi Trendy
-DocType: Process Payroll,Bimonthly,dvouměsíčník
+DocType: Payroll Entry,Bimonthly,dvouměsíčník
 DocType: Vehicle Service,Brake Pad,Brzdový pedál
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +115,Research & Development,Výzkum a vývoj
+DocType: Fertilizer,Fertilizer Contents,Obsah hnojiv
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Výzkum a vývoj
 apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Částka k Fakturaci
 DocType: Company,Registration Details,Registrace Podrobnosti
 DocType: Timesheet,Total Billed Amount,Celková částka Fakturovaný
@@ -1056,16 +1133,18 @@
 DocType: Sales Team,Incentives,Pobídky
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +64,Register for Hub,Zaregistrujte se do Hubu
 DocType: SMS Log,Requested Numbers,Požadované Čísla
+DocType: Volunteer,Evening,Večer
 DocType: Production Planning Tool,Only Obtain Raw Materials,Vypsat pouze slkadový materiál
-apps/erpnext/erpnext/config/hr.py +142,Performance appraisal.,Hodnocení výkonu.
+DocType: Customer,Bypass credit limit check at Sales Order,Zablokujte kontrolu úvěrového limitu na objednávce
+apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Hodnocení výkonu.
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Povolení &quot;použití pro nákupního košíku&quot;, jak je povoleno Nákupní košík a tam by měla být alespoň jedna daňová pravidla pro Košík"
-apps/erpnext/erpnext/controllers/accounts_controller.py +347,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Platba Vstup {0} je propojen na objednávku {1}, zkontrolujte, zda by měl být tažen za pokrok v této faktuře."
+apps/erpnext/erpnext/controllers/accounts_controller.py +391,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Platba Vstup {0} je propojen na objednávku {1}, zkontrolujte, zda by měl být tažen za pokrok v této faktuře."
 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 +321,Point-of-Sale,Místě prodeje
 DocType: Fee Schedule,Fee Creation Status,Stav tvorby poplatků
 DocType: Vehicle Log,Odometer Reading,stav tachometru
-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"""
+apps/erpnext/erpnext/accounts/doctype/account/account.py +118,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","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ů
@@ -1074,12 +1153,15 @@
 DocType: Purchase Invoice Item,Rejected Qty,zamítnuta Množství
 DocType: Setup Progress Action,Action Field,Pole akce
 DocType: Healthcare Settings,Manage Customer,Správa zákazníka
+DocType: Delivery Trip,Delivery Stops,Doručování se zastaví
 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/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Povolit Hub
-apps/erpnext/erpnext/public/js/setup_wizard.js +107,The name of your company for which you are setting up this system.,"Název vaší společnosti, pro kterou nastavení tohoto systému."
+apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,"Název vaší společnosti, pro kterou nastavení tohoto systému."
 DocType: HR Settings,Include holidays in Total no. of Working Days,Zahrnout dovolenou v celkovém. pracovních dní
+apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Nastavte svůj institut v ERPNext
+DocType: Agriculture Analysis Criteria,Plant Analysis,Analýza rostlin
 DocType: Job Applicant,Hold,Držet
 DocType: Employee,Date of Joining,Datum přistoupení
 DocType: Naming Series,Update Series,Řada Aktualizace
@@ -1087,27 +1169,31 @@
 DocType: Restaurant Table,Minimum Seating,Minimální počet sedadel
 DocType: Item Attribute,Item Attribute Values,Položka Hodnoty atributů
 DocType: Examination Result,Examination Result,vyšetření Výsledek
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +817,Purchase Receipt,Příjemka
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +843,Purchase Receipt,Příjemka
 ,Received Items To Be Billed,"Přijaté položek, které mají být účtovány"
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +173,Submitted Salary Slips,Vložené výplatních páskách
-apps/erpnext/erpnext/config/accounts.py +311,Currency exchange rate master.,Devizový kurz master.
+apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Devizový kurz master.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +198,Reference Doctype must be one of {0},Referenční Doctype musí být jedním z {0}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +302,Unable to find Time Slot in the next {0} days for Operation {1},Nelze najít časový úsek v příštích {0} dní k provozu {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +322,Unable to find Time Slot in the next {0} days for Operation {1},Nelze najít časový úsek v příštích {0} dní k provozu {1}
 DocType: Production Order,Plan material for sub-assemblies,Plán materiál pro podsestavy
 apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Obchodní partneři a teritoria
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +581,BOM {0} must be active,BOM {0} musí být aktivní
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +585,BOM {0} must be active,BOM {0} musí být aktivní
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +221,Closing (Opening + Total),Uzavření (otevření + celkem)
 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/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: Crop Cycle,ISO 8016 standard,ISO 8016 standard
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Pořadové číslo {0} nepatří k bodu {1}
 DocType: Purchase Receipt Item Supplied,Required Qty,Požadované množství
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Sklady se stávajícími transakce nelze převést na knihy.
 DocType: Bank Reconciliation,Total Amount,Celková částka
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +32,Internet Publishing,Internet Publishing
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Internet Publishing
 DocType: Prescription Duration,Number,Číslo
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Vytvoření faktury {0}
 DocType: Medical Code,Medical Code Standard,Standardní zdravotnický kód
+DocType: Soil Texture,Clay Composition (%),Složení jílů (%)
 DocType: Production Planning Tool,Production Orders,Výrobní Objednávky
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +62,Balance Value,Zůstatek Hodnota
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Uložte prosím před přiřazením úkolu.
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Balance Value,Zůstatek Hodnota
 DocType: Lab Test,Lab Technician,Laboratorní technik
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Prodejní ceník
 DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
@@ -1119,31 +1205,33 @@
 DocType: Supplier,Default Payable Accounts,Výchozí úplatu účty
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje
 DocType: Fee Structure,Components,Komponenty
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +251,Please enter Asset Category in Item {0},"Prosím, zadejte Kategorie majetku v položce {0}"
-apps/erpnext/erpnext/stock/doctype/item/item.py +653,Item Variants {0} updated,Bod Varianty {0} aktualizováno
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +272,Please enter Asset Category in Item {0},"Prosím, zadejte Kategorie majetku v položce {0}"
+apps/erpnext/erpnext/stock/doctype/item/item.py +634,Item Variants {0} updated,Bod Varianty {0} aktualizováno
 DocType: Quality Inspection Reading,Reading 6,Čtení 6
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
 of this","generovat. Pokud je opožděno, musíte ručně změnit pole &quot;Opakovat v den měsíce&quot;"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +919,Cannot {0} {1} {2} without any negative outstanding invoice,Nelze {0} {1} {2} bez negativních vynikající faktura
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,Nelze {0} {1} {2} bez negativních vynikající faktura
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Záloha přijaté faktury
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
-apps/erpnext/erpnext/config/accounts.py +254,Define budget for a financial year.,Definovat rozpočet pro finanční rok.
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +197,Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
+apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Definovat rozpočet pro finanční rok.
 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: Lead,LEAD-,VÉST-
 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 +47,The Brand,Brand
+DocType: Payment Terms Template,Payment Terms Template,Šablona platebních podmínek
+apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,Brand
 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: Journal Entry Account,Purchase Invoice,Přijatá faktura
 DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail No
-apps/erpnext/erpnext/accounts/page/pos/pos.js +765,New Sales Invoice,Nová prodejní faktura
+apps/erpnext/erpnext/accounts/page/pos/pos.js +780,New Sales Invoice,Nová prodejní faktura
 DocType: Stock Entry,Total Outgoing Value,Celková hodnota Odchozí
 DocType: Physician,Appointments,Setkání
 apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Datum zahájení a datem ukončení by mělo být v rámci stejného fiskální rok
 DocType: Lead,Request for Information,Žádost o informace
 ,LeaderBoard,LeaderBoard
-apps/erpnext/erpnext/accounts/page/pos/pos.js +778,Sync Offline Invoices,Sync Offline Faktury
+DocType: Sales Invoice Item,Rate With Margin (Company Currency),Sazba s marží (měna společnosti)
+apps/erpnext/erpnext/accounts/page/pos/pos.js +793,Sync Offline Invoices,Sync Offline Faktury
 DocType: Payment Request,Paid,Placený
 DocType: Program Fee,Program Fee,Program Fee
 DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
@@ -1153,13 +1241,14 @@
 DocType: Guardian,Guardian Name,Jméno Guardian
 DocType: Cheque Print Template,Has Print Format,Má formát tisku
 DocType: Employee Loan,Sanctioned,schválený
-apps/erpnext/erpnext/accounts/page/pos/pos.js +73, is mandatory. Maybe Currency Exchange record is not created for ,je povinné. Možná chybí záznam směnného kurzu pro
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +112,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 +622,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pro &quot;produktem Bundle předměty, sklad, sériové číslo a dávkové No bude považována ze&quot; Balení seznam &#39;tabulky. Pokud Warehouse a Batch No jsou stejné pro všechny balení položky pro jakoukoli &quot;Výrobek balík&quot; položky, tyto hodnoty mohou být zapsány do hlavní tabulky položky, budou hodnoty zkopírovány do &quot;Balení seznam&quot; tabulku."
-DocType: Job Opening,Publish on website,Publikovat na webových stránkách
-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 +641,Supplier Invoice Date cannot be greater than Posting Date,Dodavatel Datum faktury nemůže být větší než Datum zveřejnění
+apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,je povinné. Možná chybí záznam směnného kurzu pro
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
+DocType: Crop Cycle,Crop Cycle,Crop Cycle
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +632,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pro &quot;produktem Bundle předměty, sklad, sériové číslo a dávkové No bude považována ze&quot; Balení seznam &#39;tabulky. Pokud Warehouse a Batch No jsou stejné pro všechny balení položky pro jakoukoli &quot;Výrobek balík&quot; položky, tyto hodnoty mohou být zapsány do hlavní tabulky položky, budou hodnoty zkopírovány do &quot;Balení seznam&quot; tabulku."
+DocType: Student Admission,Publish on website,Publikovat na webových stránkách
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +645,Supplier Invoice Date cannot be greater than Posting Date,Dodavatel Datum faktury nemůže být větší než Datum zveřejnění
 DocType: Purchase Invoice Item,Purchase Order Item,Položka vydané objednávky
+DocType: Agriculture Task,Agriculture Task,Zemědělské úkoly
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Nepřímé příjmy
 DocType: Student Attendance Tool,Student Attendance Tool,Student Účast Tool
 DocType: Restaurant Menu,Price List (Auto created),Ceník (vytvořeno automaticky)
@@ -1167,55 +1256,60 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Odchylka
 ,Company Name,Název společnosti
 DocType: SMS Center,Total Message(s),Celkem zpráv (y)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +888,Select Item for Transfer,Vybrat položku pro převod
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +913,Select Item for Transfer,Vybrat položku pro převod
 DocType: Purchase Invoice,Additional Discount Percentage,Další slevy Procento
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Zobrazit seznam všech nápovědy videí
+DocType: Agriculture Analysis Criteria,Soil Texture,Půdní textury
 DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Vyberte účet šéf banky, kde byla uložena kontrola."
 DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Povolit uživateli upravovat Ceník Cena při transakcích
 DocType: Pricing Rule,Max Qty,Max Množství
 apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
 						Please enter a valid Invoice","Řádek {0}: faktura {1} je neplatná, to by mohlo být zrušeno / neexistuje. \ Zadejte platnou fakturu"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: 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/accounts/doctype/journal_entry/journal_entry.py +130,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/data/industry_type.py +16,Chemical,Chemický
 DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Výchozí banka / Peněžní účet budou automaticky aktualizovány v plat položka deníku je-li zvolen tento režim.
 DocType: BOM,Raw Material Cost(Company Currency),Raw Material Cost (Company měna)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +732,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 +758,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/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Řádek # {0}: Míra nemůže být větší než rychlost použitá v {1} {2}
-apps/erpnext/erpnext/utilities/user_progress.py +126,Meter,Metr
+apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,Metr
 DocType: Workstation,Electricity Cost,Cena elektřiny
 DocType: HR Settings,Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin
+DocType: Expense Claim,Total Advance Amount,Celková výše zálohy
+DocType: Delivery Stop,Estimated Arrival,odhadovaný příjezd
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Uložit nastavení
+DocType: Delivery Stop,Notified by Email,Oznámení emailem
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +683,Requested Products,Požadované produkty
 DocType: Item,Inspection Criteria,Inspekční Kritéria
 apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Převedené
 DocType: BOM Website Item,BOM Website Item,BOM Website Item
-apps/erpnext/erpnext/public/js/setup_wizard.js +48,Upload your letter head and logo. (you can edit them later).,Nahrajte svůj dopis hlavu a logo. (Můžete je upravit později).
+apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Nahrajte svůj dopis hlavu a logo. (Můžete je upravit později).
 DocType: Timesheet Detail,Bill,Účet
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Vedle Odpisy Datum se zadává jako uplynulém dni
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +204,White,Bílá
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Vedle Odpisy Datum se zadává jako uplynulém dni
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Bílá
 DocType: SMS Center,All Lead (Open),Všechny Lead (Otevřeny)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +231,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Řádek {0}: Množství není k dispozici pro {4} ve skladu {1} při účtování čas vložení údajů ({2} {3})
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +248,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Řádek {0}: Množství není k dispozici pro {4} ve skladu {1} při účtování čas vložení údajů ({2} {3})
 DocType: Purchase Invoice,Get Advances Paid,Získejte zaplacené zálohy
 DocType: Item,Automatically Create New Batch,Automaticky vytvořit novou dávku
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Make ,Dělat
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Make ,Dělat
 DocType: Student Admission,Admission Start Date,Vstupné Datum zahájení
 DocType: Journal Entry,Total Amount in Words,Celková částka slovy
+apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Nový zaměstnanec
 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 +158,Order Type must be one of {0},Typ objednávky musí být jedním z {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +126,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 +36,Opening Qty,Otevření POČET
 DocType: Healthcare Settings,Appointment Reminder,Připomenutí pro jmenování
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +468,Please enter Account for Change Amount,"Prosím, zadejte účet pro změnu Částka"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +472,Please enter Account for Change Amount,"Prosím, zadejte účet pro změnu Částka"
 DocType: Student Batch Name,Student Batch Name,Student Batch Name
 DocType: Consultation,Doctor,Doktor
 DocType: Holiday List,Holiday List Name,Název seznamu dovolené
 DocType: Repayment Schedule,Balance Loan Amount,Balance Výše úvěru
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.js +13,Schedule Course,rozvrh
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +224,Stock Options,Akciové opce
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,rozvrh
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Stock Options,Akciové opce
 DocType: Journal Entry Account,Expense Claim,Hrazení nákladů
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +234,Do you really want to restore this scrapped asset?,Opravdu chcete obnovit tento vyřazen aktivum?
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +358,Qty for {0},Množství pro {0}
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +254,Do you really want to restore this scrapped asset?,Opravdu chcete obnovit tento vyřazen aktivum?
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +380,Qty for {0},Množství pro {0}
 DocType: Leave Application,Leave Application,Požadavek na absenci
 DocType: Patient,Patient Relation,Vztah pacienta
 apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Nástroj pro přidělování dovolených
@@ -1231,18 +1325,22 @@
 apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Zadejte {0}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Removed items with no change in quantity or value.,Odstraněné položky bez změny množství nebo hodnoty.
 DocType: Delivery Note,Delivery To,Doručení do
-apps/erpnext/erpnext/stock/doctype/item/item.py +682,Attribute table is mandatory,Atribut tabulka je povinné
+apps/erpnext/erpnext/stock/doctype/item/item.js +384,Variant creation has been queued.,Tvorba variantu byla zařazena do fronty.
+apps/erpnext/erpnext/stock/doctype/item/item.py +668,Attribute table is mandatory,Atribut tabulka je povinné
 DocType: Production Planning Tool,Get Sales Orders,Získat Prodejní objednávky
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} nemůže být negativní
 DocType: Training Event,Self-Study,Samostudium
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +480,Discount,Sleva
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +537,Discount,Sleva
+DocType: Membership,Membership,Členství
 DocType: Asset,Total Number of Depreciations,Celkový počet Odpisy
 DocType: Sales Invoice Item,Rate With Margin,Míra s marží
 DocType: Workstation,Wages,Mzdy
-DocType: Task,Urgent,Naléhavý
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +157,Please specify a valid Row ID for row {0} in table {1},Zadejte prosím platný řádek ID řádku tabulky {0} {1}
+DocType: Asset Maintenance,Maintenance Manager Name,Název správce údržby
+DocType: Agriculture Task,Urgent,Naléhavý
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Zadejte prosím platný řádek ID řádku tabulky {0} {1}
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Nelze najít proměnnou:
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +664,Please select a field to edit from numpad,"Vyberte pole, které chcete upravit z čísla"
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +723,Please select a field to edit from numpad,"Vyberte pole, které chcete upravit z čísla"
+apps/erpnext/erpnext/stock/doctype/item/item.py +253,Cannot be a fixed asset item as Stock Ledger is created.,"Nemůže být položka fixního aktiva, protože je vytvořena účetní kniha akcií."
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Přejděte na plochu a začít používat ERPNext
 DocType: Item,Manufacturer,Výrobce
 DocType: Landed Cost Item,Purchase Receipt Item,Položka příjemky
@@ -1251,12 +1349,11 @@
 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 +72,Selling Amount,Prodejní Částka
 DocType: Repayment Schedule,Interest Amount,Zájem Částka
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +109,You are the Expense Approver for this record. Please Update the 'Status' and Save,"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 +120,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
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Evidence
 DocType: Asset,Scrapped,sešrotován
-apps/erpnext/erpnext/config/stock.py +200,"Attributes for Item Variants. e.g Size, Color etc.","Atributy pro položky varianty. například velikost, barva atd."
 DocType: Purchase Invoice,Returns,výnos
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP Warehouse
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Pořadové číslo {0} je na základě smlouvy o údržbě aľ {1}
@@ -1265,7 +1362,8 @@
 DocType: Tax Rule,Shipping State,Přepravní State
 ,Projected Quantity as Source,Množství projekcí as Zdroj
 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ána pomocí tlačítka""položka získaná z dodacího listu"""
-DocType: Employee,A-,A-
+DocType: Delivery Trip,Delivery Trip,Výlet za doručení
+DocType: Student,A-,A-
 DocType: Production Planning Tool,Include non-stock items,Včetně neskladových položek
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Prodejní náklady
 DocType: Consultation,Diagnosis,Diagnóza
@@ -1273,8 +1371,8 @@
 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/accounts/page/pos/pos.js +1598,ZIP Code,PSČ
-apps/erpnext/erpnext/controllers/selling_controller.py +271,Sales Order {0} is {1},Prodejní objednávky {0} {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1613,ZIP Code,PSČ
+apps/erpnext/erpnext/controllers/selling_controller.py +245,Sales Order {0} is {1},Prodejní objednávky {0} {1}
 DocType: Opportunity,Contact Info,Kontaktní informace
 apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Tvorba přírůstků zásob
 DocType: Packing Slip,Net Weight UOM,Hmotnost UOM
@@ -1286,18 +1384,21 @@
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,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.,Vyberte název společnosti jako první.
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +181,Low to High,Nízká až vysoká
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +202,Email sent to {0},Email odeslán (komu) {0}
 apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Nabídka obdržená od Dodavatelů.
 apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Nahraďte kusovníku a aktualizujte nejnovější cenu ve všech kusovnících
 apps/erpnext/erpnext/controllers/selling_controller.py +24,To {0} | {1} {2},Chcete-li {0} | {1} {2}
+DocType: Delivery Trip,Driver Name,Jméno řidiče
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Průměrný věk
-DocType: School Settings,Attendance Freeze Date,Datum ukončení účasti
-apps/erpnext/erpnext/utilities/user_progress.py +89,List a few of your suppliers. They could be organizations or individuals.,Seznam několik svých dodavatelů. Ty by mohly být organizace nebo jednotlivci.
+DocType: Education Settings,Attendance Freeze Date,Datum ukončení účasti
+apps/erpnext/erpnext/utilities/user_progress.py +107,List a few of your suppliers. They could be organizations or individuals.,Seznam několik svých dodavatelů. Ty by mohly být organizace nebo jednotlivci.
 apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Zobrazit všechny produkty
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimální doba plnění (dny)
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +57,All BOMs,Všechny kusovníky
 DocType: Patient,Default Currency,Výchozí měna
 DocType: Expense Claim,From Employee,Od Zaměstnance
-apps/erpnext/erpnext/controllers/accounts_controller.py +407,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: Driver,Cellphone Number,Mobilní číslo
+apps/erpnext/erpnext/controllers/accounts_controller.py +451,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
@@ -1306,20 +1407,22 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +229,{0} {1} must be submitted,{0} {1} musí být odeslaný
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +151,Quantity must be less than or equal to {0},Množství musí být menší než nebo rovno {0}
 DocType: SMS Center,Total Characters,Celkový počet znaků
+DocType: Employee Advance,Claimed,Reklamace
+DocType: Crop,Row Spacing,Rozteč řádků
 apps/erpnext/erpnext/controllers/buying_controller.py +161,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%
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +212,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Podle Nákupních nastavení, pokud je objednávka požadována == &#39;ANO&#39;, pak pro vytvoření nákupní faktury musí uživatel nejprve vytvořit nákupní objednávku pro položku {0}"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Podle Nákupních nastavení, pokud je objednávka požadována == &#39;ANO&#39;, pak pro vytvoření nákupní faktury musí uživatel nejprve vytvořit nákupní objednávku pro položku {0}"
 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 +233,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 +68,Please set 'Apply Additional Discount On',Prosím nastavte na &quot;Použít dodatečnou slevu On&quot;
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,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 +71,Please set 'Apply Additional Discount On',Prosím nastavte na &quot;Použít dodatečnou slevu On&quot;
 ,Ordered Items To Be Billed,Objednané zboží fakturovaných
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,"Z rozsahu, musí být nižší než na Range"
 DocType: Global Defaults,Global Defaults,Globální Výchozí
-apps/erpnext/erpnext/projects/doctype/project/project.py +215,Project Collaboration Invitation,Projekt spolupráce Pozvánka
+apps/erpnext/erpnext/projects/doctype/project/project.py +226,Project Collaboration Invitation,Projekt spolupráce Pozvánka
 DocType: Salary Slip,Deductions,Odpočty
 DocType: Leave Allocation,LAL/,LAL /
 DocType: Setup Progress Action,Action Name,Název akce
@@ -1327,49 +1430,51 @@
 apps/erpnext/erpnext/regional/india/utils.py +24,First 2 digits of GSTIN should match with State number {0},První dvě číslice GSTIN by se měly shodovat s číslem státu {0}
 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,Volno bez nároku na mzdu
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,Capacity Planning Error,Plánování kapacit Chyba
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +366,Capacity Planning Error,Plánování kapacit Chyba
 ,Trial Balance for Party,Trial váhy pro stranu
 DocType: Lead,Consultant,Konzultant
 DocType: Salary Slip,Earnings,Výdělek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +391,Finished Item {0} must be entered for Manufacture type entry,Dokončeno Položka {0} musí být zadán pro vstup typu Výroba
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +416,Finished Item {0} must be entered for Manufacture type entry,Dokončeno Položka {0} musí být zadán pro vstup typu Výroba
 apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Otevření účetnictví Balance
 ,GST Sales Register,Obchodní registr GST
 DocType: Sales Invoice Advance,Sales Invoice Advance,Prodejní faktury Advance
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Nothing to request,Nic požadovat
+apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Vyberte své domény
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Další rekord Rozpočet &#39;{0}&#39; již existuje proti {1} &#39;{2}&#39; za fiskální rok {3}
+DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Pole budou kopírovány pouze v době vytváření.
 apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date',"""Skutečné datum zahájení"" nemůže být větší než ""Skutečné datum ukončení"""
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +113,Management,Řízení
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Řízení
 DocType: Cheque Print Template,Payer Settings,Nastavení plátce
 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."
 DocType: Purchase Invoice,Is Return,Je Return
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +80,Caution,Pozor
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +787,Return / Debit Note,Return / vrubopis
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,Caution,Pozor
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,Return / Debit Note,Return / vrubopis
 DocType: Price List Country,Price List Country,Ceník Země
 DocType: Item,UOMs,UOMs
-apps/erpnext/erpnext/stock/utils.py +205,{0} valid serial nos for Item {1},{0} platí pořadová čísla pro položky {1}
+apps/erpnext/erpnext/stock/utils.py +210,{0} valid serial nos for Item {1},{0} platí pořadová čísla pro 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 +26,POS Profile {0} already created for user: {1} and company {2},POS Profile {0} již vytvořili pro uživatele: {1} a společnost {2}
-DocType: Sales Invoice Item,UOM Conversion Factor,UOM Conversion Factor
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +23,Please enter Item Code to get Batch Number,"Prosím, zadejte kód položky se dostat číslo šarže"
+DocType: Purchase Invoice Item,UOM Conversion Factor,UOM Conversion Factor
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,"Prosím, zadejte kód položky se dostat číslo šarže"
 DocType: Stock Settings,Default Item Group,Výchozí bod Group
 DocType: Employee Loan,Partially Disbursed,částečně Vyplacené
+apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Poskytněte informace.
 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 +701,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 +748,Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
 DocType: Fee Validity,Valid Till,Platný do
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2454,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Režim platba není nakonfigurován. Prosím zkontrolujte, zda je účet byl nastaven na režim plateb nebo na POS Profilu."
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2473,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Režim platba není nakonfigurován. Prosím zkontrolujte, zda je účet byl nastaven na režim plateb nebo na POS Profilu."
 apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Stejnou položku nelze zadat vícekrát.
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Further accounts can be made under Groups, but entries can be made against non-Groups","Další účty mohou být vyrobeny v rámci skupiny, ale údaje lze proti non-skupin"
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups","Další účty mohou být vyrobeny v rámci skupiny, ale údaje lze proti non-skupin"
 DocType: Lead,Lead,Lead
 DocType: Email Digest,Payables,Závazky
 DocType: Course,Course Intro,Samozřejmě Intro
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Prosím, nastavte číselnou sérii pro Účast přes Nastavení&gt; Číslovací série"
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +90,Stock Entry {0} created,Skladovou pohyb {0} vytvořil
-apps/erpnext/erpnext/controllers/buying_controller.py +297,Row #{0}: Rejected Qty can not be entered in Purchase Return,Řádek # {0}: Zamítnutí Množství nemůže být zapsán do kupní Návrat
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +97,Stock Entry {0} created,Skladovou pohyb {0} vytvořil
+apps/erpnext/erpnext/controllers/buying_controller.py +298,Row #{0}: Rejected Qty can not be entered in Purchase Return,Řádek # {0}: Zamítnutí Množství nemůže být zapsán do kupní Návrat
 ,Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Updating estimated arrival times.,Aktualizace odhadovaných časů příjezdu.
 DocType: Purchase Invoice Item,Net Rate,Čistá míra
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +151,Please select a customer,Vyberte zákazníka
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +147,Please select a customer,Vyberte zákazníka
 DocType: Purchase Invoice Item,Purchase Invoice Item,Položka přijaté faktury
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,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
@@ -1382,28 +1487,31 @@
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Pořadí objednávek
 DocType: Global Defaults,Current Fiscal Year,Aktuální fiskální rok
 DocType: Purchase Order,Group same items,Skupina stejné položky
-DocType: Global Defaults,Disable Rounded Total,Zakázat Zaoblený Celkem
+DocType: Purchase Invoice,Disable Rounded Total,Zakázat Zaoblený Celkem
 DocType: Employee Loan Application,Repayment Info,splácení Info
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,"""Záznamy"" nemohou být prázdné"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +446,'Entries' cannot be empty,"""Záznamy"" nemohou být prázdné"
+DocType: Maintenance Team Member,Maintenance Role,Úloha údržby
 apps/erpnext/erpnext/utilities/transaction_base.py +81,Duplicate row {0} with same {1},Duplicitní řádek {0} se stejným {1}
 ,Trial Balance,Trial Balance
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +449,Fiscal Year {0} not found,Fiskální rok {0} nebyl nalezen
-apps/erpnext/erpnext/config/hr.py +300,Setting up Employees,Nastavení Zaměstnanci
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Fiskální rok {0} nebyl nalezen
+apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Nastavení Zaměstnanci
 DocType: Sales Order,SO-,TAK-
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,"Prosím, vyberte první prefix"
-DocType: Employee,O-,Ó-
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +185,Research,Výzkum
+DocType: Student,O-,Ó-
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Výzkum
 DocType: Maintenance Visit Purpose,Work Done,Odvedenou práci
 apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,Uveďte prosím alespoň jeden atribut v tabulce atributy
 DocType: Announcement,All Students,Všichni studenti
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Item {0} musí být non-skladová položka
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Item {0} musí být non-skladová položka
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,View Ledger
 DocType: Grading Scale,Intervals,intervaly
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Nejstarší
-apps/erpnext/erpnext/stock/doctype/item/item.py +519,"An Item Group exists with same name, please change the item name or rename the item group","Skupina položek již existuje. Prosím, změňte název položky nebo přejmenujte skupinu položek"
-apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +367,Rest Of The World,Zbytek světa
+apps/erpnext/erpnext/stock/doctype/item/item.py +500,"An Item Group exists with same name, please change the item name or rename the item group","Skupina položek již existuje. Prosím, změňte název položky nebo přejmenujte skupinu položek"
+DocType: Crop Cycle,Less than a year,Méně než rok
+apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Zbytek světa
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Položka {0} nemůže mít dávku
+DocType: Crop,Yield UOM,Výnos UOM
 ,Budget Variance Report,Rozpočet Odchylka Report
 DocType: Salary Slip,Gross Pay,Hrubé mzdy
 DocType: Item,Is Item from Hub,Je položka z Hubu
@@ -1422,7 +1530,6 @@
 DocType: Student,STUD.,STUD.
 DocType: Production Order,Qty To Manufacture,Množství K výrobě
 DocType: Email Digest,New Income,New příjmů
-DocType: School Settings,School Settings,Nastavení školy
 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
 ,Student and Guardian Contact Details,Student a Guardian Kontaktní údaje
@@ -1434,26 +1541,27 @@
 DocType: Patient Appointment,More Info,Více informací
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +178,Valuation Rate required for Item in row {0},Ocenění Míra potřebná pro položku v řádku {0}
 DocType: Supplier Scorecard,Scorecard Actions,Akční body Scorecard
-apps/erpnext/erpnext/utilities/user_progress.py +148,Example: Masters in Computer Science,Příklad: Masters v informatice
+apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Příklad: Masters v informatice
 DocType: Purchase Invoice,Rejected Warehouse,Zamítnuto Warehouse
 DocType: GL Entry,Against Voucher,Proti poukazu
 DocType: Item,Default Buying Cost Center,Výchozí středisko nákupu
 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.","Chcete-li získat to nejlepší z ERPNext, doporučujeme vám nějaký čas trvat, a sledovat tyto nápovědy videa."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +74, to ,na
+apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,na
 DocType: Supplier Quotation Item,Lead Time in days,Čas leadu ve dnech
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Splatné účty Shrnutí
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +337,Payment of salary from {0} to {1},Výplata platu od {0} do {1}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},Výplata platu od {0} do {1}
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,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 +70,Sales Order {0} is not valid,Prodejní objednávky {0} není platný
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Prodejní objednávky {0} není platný
 DocType: Supplier Scorecard,Warn for new Request for Quotations,Upozornit na novou žádost o nabídky
 apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Objednávky pomohou při plánování a navázat na vašich nákupech
-apps/erpnext/erpnext/setup/doctype/company/company.py +218,"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
+apps/erpnext/erpnext/setup/doctype/company/company.py +215,"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Předpisy pro laboratorní testy
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +162,"The total Issue / Transfer quantity {0} in Material Request {1}  \
 							cannot be greater than requested quantity {2} for Item {3}",Celkové emise / přenosu množství {0} v hmotné Request {1} \ nemůže být vyšší než požadované množství {2} pro položku {3}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +193,Small,Malý
-DocType: Employee,Employee Number,Počet zaměstnanců
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,Malý
+DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Otevření položky nástroje pro vytváření faktur
+DocType: Education Settings,Employee Number,Počet zaměstnanců
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},Případ číslo (čísla) již v provozu. Zkuste se věc č {0}
 DocType: Project,% Completed,% Dokončeno
 ,Invoiced Amount (Exculsive Tax),Fakturovaná částka (bez daně)
@@ -1463,17 +1571,20 @@
 DocType: Item,Auto re-order,Automatické znovuobjednání
 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 +97,Contract,Smlouva
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Smlouva
+DocType: Plant Analysis,Laboratory Testing Datetime,Laboratorní testování Datetime
 DocType: Email Digest,Add Quote,Přidat nabídku
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +869,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/stock/doctype/stock_entry/stock_entry.py +932,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 +92,Indirect Expenses,Nepřímé náklady
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Zemědělství
-apps/erpnext/erpnext/accounts/page/pos/pos.js +770,Sync Master Data,Sync Master Data
-apps/erpnext/erpnext/utilities/user_progress.py +117,Your Products or Services,Vaše Produkty nebo Služby
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
+DocType: Agriculture Analysis Criteria,Agriculture,Zemědělství
+apps/erpnext/erpnext/accounts/page/pos/pos.js +785,Sync Master Data,Sync Master Data
+DocType: Asset Repair,Repair Cost,náklady na opravu
+apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Vaše Produkty nebo Služby
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Přihlášení selhalo
 DocType: Special Test Items,Special Test Items,Speciální zkušební položky
 DocType: Mode of Payment,Mode of Payment,Způsob platby
-apps/erpnext/erpnext/stock/doctype/item/item.py +190,Website Image should be a public file or website URL,Webové stránky Image by měla být veřejná souboru nebo webové stránky URL
+apps/erpnext/erpnext/stock/doctype/item/item.py +192,Website Image should be a public file or website URL,Webové stránky Image by měla být veřejná souboru nebo webové stránky URL
 DocType: Student Applicant,AP,AP
 DocType: Purchase Invoice Item,BOM,BOM
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.
@@ -1481,49 +1592,52 @@
 DocType: Vehicle,Fuel UOM,palivo UOM
 DocType: Warehouse,Warehouse Contact Info,Sklad Kontaktní informace
 DocType: Payment Entry,Write Off Difference Amount,Odepsat Difference Částka
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +415,"{0}: Employee email not found, hence email not sent","{0}: e-mail zaměstnanec nebyl nalezen, a proto je pošta neposlal"
+DocType: Volunteer,Volunteer Name,Jméno dobrovolníka
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: e-mail zaměstnanec nebyl nalezen, a proto je pošta neposlal"
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Pravidlo odeslání se nevztahuje na zemi {0}
 DocType: Item,Foreign Trade Details,Zahraniční obchod Podrobnosti
 ,Assessment Plan Status,Stav plánu hodnocení
 DocType: Email Digest,Annual Income,Roční příjem
 DocType: Serial No,Serial No Details,Serial No Podrobnosti
 DocType: Purchase Invoice Item,Item Tax Rate,Sazba daně položky
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +67,Please select Physician and Date,Zvolte lékaře a datum
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Zvolte lékaře a datum
 DocType: Student Group Student,Group Roll Number,Číslo role skupiny
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"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/projects/doctype/project/project.py +78,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Součet všech vah úkol by měl být 1. Upravte váhy všech úkolů projektu v souladu
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +578,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
-apps/erpnext/erpnext/stock/get_item_details.py +151,Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +143,"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/projects/doctype/project/project.py +80,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Součet všech vah úkol by měl být 1. Upravte váhy všech úkolů projektu v souladu
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +582,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
+apps/erpnext/erpnext/stock/get_item_details.py +146,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 +43,Capital Equipments,Kapitálové Vybavení
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Ceny Pravidlo je nejprve vybrána na základě ""Použít na"" oblasti, které mohou být položky, položky skupiny nebo značky."
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +223,Please set the Item Code first,Nejprve nastavte kód položky
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +245,Please set the Item Code first,Nejprve nastavte kód položky
 DocType: Item,ITEM-,POLOŽKA-
-apps/erpnext/erpnext/controllers/selling_controller.py +151,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/controllers/selling_controller.py +119,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
 DocType: Sales Invoice Item,Edit Description,Upravit popis
 DocType: Antibiotic,Antibiotic,Antibiotikum
 ,Team Updates,tým Aktualizace
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +885,For Supplier,Pro Dodavatele
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +910,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/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Vytvořit formát tisku
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Poplatek byl vytvořen
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Poplatek byl vytvořen
 apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Nenalezl žádnou položku s názvem {0}
 DocType: Supplier Scorecard Criteria,Criteria Formula,Kritéria vzorce
 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 +47,"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"""
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","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
 DocType: Patient Appointment,Duration,Doba trvání
 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.
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,Dítě sklad existuje pro tento sklad. Nemůžete odstranit tento sklad.
 DocType: Item,Website Item Groups,Webové stránky skupiny položek
 DocType: Purchase Invoice,Total (Company Currency),Total (Company měny)
-apps/erpnext/erpnext/stock/utils.py +200,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
+apps/erpnext/erpnext/stock/utils.py +205,Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou
+DocType: Journal Entry,Journal Entry,Zápis do deníku
+DocType: Expense Claim Advance,Unclaimed amount,Nevyžádaná částka
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,{0} položky v probíhající
 DocType: Workstation,Workstation Name,Meno pracovnej stanice
 DocType: Grading Scale Interval,Grade Code,Grade Code
 DocType: POS Item Group,POS Item Group,POS položky Group
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,E-mail Digest:
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +587,BOM {0} does not belong to Item {1},BOM {0} nepatří k bodu {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +591,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.,Bankovní účet č.
 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
@@ -1538,11 +1652,11 @@
 DocType: BOM Operation,Workstation,Pracovní stanice
 DocType: Request for Quotation Supplier,Request for Quotation Supplier,Žádost o cenovou nabídku dodavatele
 DocType: Healthcare Settings,Registration Message,Registrační zpráva
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +150,Hardware,Technické vybavení
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Technické vybavení
 DocType: Prescription Dosage,Prescription Dosage,Dávkování na předpis
 DocType: Attendance,HR Manager,HR Manager
-apps/erpnext/erpnext/accounts/party.py +177,Please select a Company,Vyberte společnost
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Privilege Leave,Privilege Leave
+apps/erpnext/erpnext/accounts/party.py +178,Please select a Company,Vyberte společnost
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Privilege Leave
 DocType: Purchase Invoice,Supplier Invoice Date,Dodavatelské faktury Datum
 apps/erpnext/erpnext/templates/includes/product_page.js +18,per,za
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Musíte povolit Nákupní košík
@@ -1554,7 +1668,7 @@
 ,BOM Browser,Prohlížeč kusovníku
 apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Aktualizujte svůj stav pro tuto tréninkovou akci
 DocType: Purchase Taxes and Charges,Add or Deduct,Přidat nebo Odečíst
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +82,Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,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/demo/setup/setup_data.py +328,Food,Jídlo
@@ -1562,7 +1676,7 @@
 DocType: Maintenance Schedule Item,No of Visits,Počet návštěv
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Plán údržby {0} existuje proti {1}
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +118,Do you want to publish your Items to Hub ?,Chcete publikovat své položky do Hubu?
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +36,Enrolling student,učící studenta
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,učící studenta
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},"Měna závěrečného účtu, musí být {0}"
 apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Součet bodů za všech cílů by mělo být 100. Je {0}
 DocType: Project,Start and End Dates,Datum zahájení a ukončení
@@ -1574,7 +1688,7 @@
 DocType: Rename Tool,Utilities,Utilities
 DocType: POS Profile,Accounting,Účetnictví
 DocType: Employee,EMP/,EMP /
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +123,Please select batches for batched item ,Zvolte dávky pro doručenou položku
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Zvolte dávky pro doručenou položku
 DocType: Asset,Depreciation Schedules,odpisy Plány
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Období pro podávání žádostí nemůže být alokační období venku volno
 DocType: Activity Cost,Projects,Projekty
@@ -1587,7 +1701,7 @@
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Avg Daily Odchozí
 DocType: POS Profile,Campaign,Kampaň
 DocType: Supplier,Name and Type,Název a typ
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +64,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 +66,Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto"""
 DocType: Physician,Contacts and Address,Kontakty a adresa
 DocType: Purchase Invoice,Contact Person,Kontaktní osoba
 apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date',"""Očekávané datum započetí"" nemůže být větší než ""Očekávané datum ukončení"""
@@ -1595,14 +1709,15 @@
 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: Water Analysis,Water Analysis Criteria,Kritéria analýzy vody
 DocType: Item,Maintain Stock,Udržovat stav zásob
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +212,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 +217,Stock Entries already created for Production Order ,Fotky Položky již vytvořené pro výrobní zakázku
 DocType: Employee,Prefered Email,preferovaný Email
 DocType: Student Admission,Eligibility and Details,Způsobilost a podrobnosti
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Čistá změna ve stálých aktiv
 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 +663,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 +359,Max: {0},Max: {0}
+apps/erpnext/erpnext/controllers/accounts_controller.py +775,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"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 +381,Max: {0},Max: {0}
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Od datetime
 DocType: Email Digest,For Company,Pro Společnost
 apps/erpnext/erpnext/config/support.py +17,Communication log.,Komunikační protokol.
@@ -1611,18 +1726,19 @@
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +73,Buying Amount,Nákup Částka
 DocType: Sales Invoice,Shipping Address Name,Název dodací adresy
 DocType: Material Request,Terms and Conditions Content,Podmínky Content
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +555,cannot be greater than 100,nemůže být větší než 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +734,Item {0} is not a stock Item,Položka {0} není skladem
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Došlo k chybám při vytváření plánu rozvrhů
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +580,cannot be greater than 100,nemůže být větší než 100
+apps/erpnext/erpnext/stock/doctype/item/item.py +720,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 Detail,Depends on Leave Without Pay,Závisí na dovolené 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
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +115,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Řádek # {0}: Dávka {1} má pouze {2} qty. Vyberte prosím jinou dávku, která má k dispozici {3} qty nebo rozdělit řádek do více řádků, doručit / vydávat z více dávek"
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Řádek # {0}: Dávka {1} má pouze {2} qty. Vyberte prosím jinou dávku, která má k dispozici {3} qty nebo rozdělit řádek do více řádků, doručit / vydávat z více dávek"
 DocType: Vehicle,License Plate,poznávací značka
 DocType: Appraisal,Goals,Cíle
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +326,Select POS Profile,Zvolte Profil POS
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +343,Select POS Profile,Zvolte Profil POS
 DocType: Warranty Claim,Warranty / AMC Status,Záruka / AMC Status
 ,Accounts Browser,Účty Browser
 DocType: Payment Entry Reference,Payment Entry Reference,Platba Vstup reference
@@ -1631,25 +1747,28 @@
 ,Batch-Wise Balance History,Batch-Wise Balance History
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Nastavení tisku aktualizovány v příslušném formátu tisku
 DocType: Package Code,Package Code,Code Package
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +101,Apprentice,Učeň
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,Učeň
 DocType: Purchase Invoice,Company GSTIN,Společnost GSTIN
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Negativní množství není dovoleno
 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ů"
 DocType: Supplier Scorecard Period,SSC-,SSC-
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +154,Employee cannot report to himself.,Zaměstnanec nemůže odpovídat sám sobě.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,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/accounts/party.py +245,Accounting Entry for {0}: {1} can only be made in currency: {2},Účetní záznam pro {0}: {1} mohou být prováděny pouze v měně: {2}
+apps/erpnext/erpnext/accounts/party.py +243,Accounting Entry for {0}: {1} can only be made in currency: {2},Účetní záznam pro {0}: {1} mohou být prováděny pouze v měně: {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 +191,Tax Rule for transactions.,Daňové Pravidlo pro transakce.
+apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Daňové Pravidlo pro transakce.
 DocType: Rename Tool,Type of document to rename.,Typ dokumentu přejmenovat.
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Zákazník je nutná proti pohledávek účtu {2}
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Zákazník je vyžadován oproti účtu pohledávek {2}
 DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Celkem Daně a poplatky (Company Měnové)
+DocType: Weather,Weather Parameter,Parametr počasí
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Ukázat P &amp; L zůstatky neuzavřený fiskální rok je
 DocType: Lab Test Template,Collection Details,Podrobnosti o kolekci
+DocType: POS Profile,Allow Print Before Pay,Povolit tisk před zaplacením
+DocType: Land Unit,Linked Soil Texture,Spojená půdní struktura
 DocType: Shipping Rule,Shipping Account,Přepravní účtu
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Účet {2} je neaktivní
 apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,"Udělat Prodejní objednávky, které vám pomohou plánovat svou práci a doručit na čas"
@@ -1657,44 +1776,48 @@
 DocType: Stock Entry,Total Additional Costs,Celkem Dodatečné náklady
 DocType: Course Schedule,SH,SH
 DocType: BOM,Scrap Material Cost(Company Currency),Šrot materiálové náklady (Company měna)
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Sub Assemblies,Podsestavy
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Podsestavy
 DocType: Asset,Asset Name,Asset Name
 DocType: Project,Task Weight,úkol Hmotnost
 DocType: Shipping Rule Condition,To Value,Chcete-li hodnota
 DocType: Asset Movement,Stock Manager,Reklamní manažer
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +144,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +809,Packing Slip,Balící list
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +149,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Platba v řádku {0} je možná duplikát.
+apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Zemědělství (beta)
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +856,Packing Slip,Balící list
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Pronájem kanceláře
 apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Nastavení SMS brány
+DocType: Disease,Common Name,Běžné jméno
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Import se nezdařil!
 apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Žádná adresa přidán dosud.
 DocType: Workstation Working Hour,Workstation Working Hour,Pracovní stanice Pracovní Hour
 DocType: Vital Signs,Blood Pressure,Krevní tlak
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +121,Analyst,Analytik
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,Analytik
 DocType: Item,Inventory,Inventář
 DocType: Item,Sales Details,Prodejní Podrobnosti
 DocType: Quality Inspection,QI-,QI-
 DocType: Opportunity,With Items,S položkami
+DocType: Asset Maintenance,Maintenance Team,Tým údržby
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,V Množství
-DocType: School Settings,Validate Enrolled Course for Students in Student Group,Ověřte zapsaný kurz pro studenty ve skupině studentů
+DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Ověřte zapsaný kurz pro studenty ve skupině studentů
 DocType: Notification Control,Expense Claim Rejected,Uhrazení výdajů zamítnuto
 DocType: Item,Item Attribute,Položka Atribut
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +143,Government,Vláda
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,Vláda
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Náklady na pojistná {0} již existuje pro jízd
-apps/erpnext/erpnext/public/js/setup_wizard.js +60,Institute Name,Jméno Institute
+apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Jméno Institute
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,"Prosím, zadejte splácení Částka"
 apps/erpnext/erpnext/config/stock.py +305,Item Variants,Položka Varianty
-DocType: Company,Services,Služby
+apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Služby
 DocType: HR Settings,Email Salary Slip to Employee,Email výplatní pásce pro zaměstnance
 DocType: Cost Center,Parent Cost Center,Nadřazené Nákladové středisko
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1017,Select Possible Supplier,Vyberte Možné dodavatele
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1039,Select Possible Supplier,Vyberte Možné dodavatele
 DocType: Sales Invoice,Source,Zdroj
 apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Show uzavřen
 DocType: Leave Type,Is Leave Without Pay,Je odejít bez Pay
-apps/erpnext/erpnext/stock/doctype/item/item.py +248,Asset Category is mandatory for Fixed Asset item,Asset kategorie je povinný pro položku dlouhodobých aktiv
+apps/erpnext/erpnext/stock/doctype/item/item.py +250,Asset Category is mandatory for Fixed Asset item,Asset kategorie je povinný pro položku dlouhodobých aktiv
 DocType: Fee Validity,Fee Validity,Platnost poplatku
 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/schools/utils.py +19,This {0} conflicts with {1} for {2} {3},Tato {0} je v rozporu s {1} o {2} {3}
+apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Tato {0} je v rozporu s {1} o {2} {3}
 DocType: Student Attendance Tool,Students HTML,studenti HTML
 DocType: POS Profile,Apply Discount,Použít slevu
 DocType: GST HSN Code,GST HSN Code,GST HSN kód
@@ -1709,16 +1832,18 @@
 apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Zaujatý
 DocType: Student,Date of Leaving,Datem odchodu
 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/setup/setup_wizard/data/industry_type.py +27,Executive Search,Executive Search
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Nastavení výchozích hodnot
 apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,vytvoření vede
 DocType: Maintenance Schedule,Schedules,Plány
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +331,POS Profile is required to use Point-of-Sale,Profil POS je vyžadován pro použití prodejního místa
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +451,POS Profile is required to use Point-of-Sale,Profil POS je vyžadován pro použití prodejního místa
 DocType: Purchase Invoice Item,Net Amount,Čistá částka
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +138,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nebyla odeslána, takže akce nemůže být dokončena"
 DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail No
 DocType: Landed Cost Voucher,Additional Charges,Další poplatky
 DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatečná sleva Částka (Měna Company)
 DocType: Supplier Scorecard,Supplier Scorecard,Hodnotící karta dodavatele
+DocType: Plant Analysis,Result Datetime,Výsledek Datetime
 apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,"Prosím, vytvořte nový účet z grafu účtů."
 ,Support Hour Distribution,Distribuce hodinové podpory
 DocType: Maintenance Visit,Maintenance Visit,Maintenance Visit
@@ -1728,10 +1853,12 @@
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Aktualizace Print Format
 DocType: Landed Cost Voucher,Landed Cost Help,Přistálo Náklady Help
 DocType: Purchase Invoice,Select Shipping Address,Zvolit adresu pro dodání
+apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Podrobnosti o členství
 DocType: Leave Block List,Block Holidays on important days.,Blokové Dovolená na významných dnů.
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Pohledávky Shrnutí
 DocType: Employee Loan,Monthly Repayment Amount,Výše měsíční splátky
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +191,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/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Otevření faktur
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,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,UOM Name
 DocType: GST HSN Code,HSN Code,Kód HSN
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Výše příspěvku
@@ -1739,25 +1866,25 @@
 DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,"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."
 DocType: Expense Claim,EXP,EXP
-apps/erpnext/erpnext/config/stock.py +205,Brand master.,Master Značky
-apps/erpnext/erpnext/schools/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} objeví vícekrát za sebou {2} {3}
+DocType: Water Analysis,Container,Kontejner
+apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} objeví vícekrát za sebou {2} {3}
 DocType: Healthcare Settings,Manage Sample Collection,Správa kolekce vzorků
 DocType: Program Enrollment Tool,Program Enrollments,Program Přihlášky
 DocType: Patient,Tobacco Past Use,Použití tabáku v minulosti
 DocType: Sales Invoice Item,Brand Name,Jméno značky
 DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Uživatel {0} je již přiřazen lékaři {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2638,Default warehouse is required for selected item,Výchozí sklad je vyžadováno pro vybraná položka
-apps/erpnext/erpnext/utilities/user_progress.py +125,Box,Krabice
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1014,Possible Supplier,možné Dodavatel
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2657,Default warehouse is required for selected item,Výchozí sklad je vyžadováno pro vybraná položka
+apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Krabice
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1036,Possible Supplier,možné Dodavatel
 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
-apps/erpnext/erpnext/public/js/setup_wizard.js +29,Healthcare (beta),Zdravotnictví (beta)
+apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Zdravotnictví (beta)
 DocType: Production Plan Sales Order,Production Plan Sales Order,Výrobní program prodejní objednávky
 DocType: Sales Partner,Sales Partner Target,Sales Partner Target
 DocType: Loan Type,Maximum Loan Amount,Maximální výše úvěru
 DocType: Pricing Rule,Pricing Rule,Ceny Pravidlo
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Duplicitní číslo role pro studenty {0}
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Duplicitní číslo role pro studenty {0}
 DocType: Budget,Action if Annual Budget Exceeded,Akční Pokud jde o roční rozpočet překročen
 apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Materiál Žádost o příkazu k nákupu
 DocType: Shopping Cart Settings,Payment Success URL,Platba Úspěch URL
@@ -1772,50 +1899,55 @@
 DocType: C-Form,III,III
 apps/erpnext/erpnext/config/stock.py +310,Opening Stock Balance,Počáteční cena zásob
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} musí být uvedeny pouze jednou
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +368,Not allowed to tranfer more {0} than {1} against Purchase Order {2},"Není povoleno, aby transfer více {0} než {1} proti Objednávky {2}"
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Dovolená úspěšně přidělena {0}
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Žádné položky k balení
 DocType: Shipping Rule Condition,From Value,Od hodnoty
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +555,Manufacturing Quantity is mandatory,Výrobní množství je povinné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +581,Manufacturing Quantity is mandatory,Výrobní množství je povinné
 DocType: Employee Loan,Repayment Method,splácení Metoda
 DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Pokud je zaškrtnuto, domovská stránka bude výchozí bod skupina pro webové stránky"
 DocType: Quality Inspection Reading,Reading 4,Čtení 4
-apps/erpnext/erpnext/config/hr.py +127,Claims for company expense.,Nároky na náklady firmy.
+apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Nároky na náklady firmy.
 apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Studenti jsou jádrem systému, přidejte všechny své studenty"
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Řádek # {0}: datum Světlá {1} nemůže být před Cheque Datum {2}
+DocType: Asset Maintenance Task,Certificate Required,Potřebný certifikát
 DocType: Company,Default Holiday List,Výchozí Holiday Seznam
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,Row {0}: From Time and To Time of {1} is overlapping with {2},Řádek {0}: čas od času i na čas z {1} se překrývá s {2}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Stock Závazky
 DocType: Purchase Invoice,Supplier Warehouse,Dodavatel Warehouse
 DocType: Opportunity,Contact Mobile No,Kontakt Mobil
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +356,Select Company,Vyberte společnost
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +382,Select Company,Vyberte společnost
 ,Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Uživatel {0} nemá žádný výchozí POS profil. Zaškrtněte výchozí v řádku {1} pro tohoto uživatele.
 DocType: Student Group,Set 0 for no limit,Nastavte 0 pro žádný limit
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +141,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"V den, kdy (y), na které žádáte o povolení jsou prázdniny. Nemusíte požádat o volno."
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Řádek {idx}: {field} je vyžadován pro vytvoření faktur otevření {invoice_type}
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Znovu poslat e-mail Payment
 apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Nová úloha
 DocType: Consultation,Appointment,Jmenování
 apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Vytvořit nabídku
 apps/erpnext/erpnext/config/selling.py +216,Other Reports,Ostatní zprávy
+apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Vyberte alespoň jednu doménu.
 DocType: Dependent Task,Dependent Task,Závislý Task
-apps/erpnext/erpnext/stock/doctype/item/item.py +414,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 +430,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 +208,Leave of type {0} cannot be longer than {1},Absence typu {0} nemůže být delší než {1}
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,Zkuste plánování operací pro X dní předem.
 DocType: HR Settings,Stop Birthday Reminders,Zastavit připomenutí narozenin
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +250,Please set Default Payroll Payable Account in Company {0},"Prosím nastavit výchozí mzdy, splatnou účet ve firmě {0}"
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},"Prosím nastavit výchozí mzdy, splatnou účet ve firmě {0}"
 DocType: SMS Center,Receiver List,Přijímač Seznam
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1068,Search Item,Hledání položky
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1083,Search Item,Hledání položky
+DocType: Payment Schedule,Payment Amount,Částka platby
 DocType: Patient Appointment,Referring Physician,Odpovídající lékař
 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/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Čistá změna v hotovosti
 DocType: Assessment Plan,Grading Scale,Klasifikační stupnice
-apps/erpnext/erpnext/stock/doctype/item/item.py +409,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/manufacturing/doctype/production_order/production_order.py +612,Already completed,již byly dokončeny
+apps/erpnext/erpnext/stock/doctype/item/item.py +425,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/manufacturing/doctype/production_order/production_order.py +616,Already completed,již byly dokončeny
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Skladem v ruce
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Import byl úspěšný!
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Platba Poptávka již 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
 DocType: Physician,Hospital,NEMOCNICE
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +362,Quantity must not be more than {0},Množství nesmí být větší než {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +384,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 +117,Previous Financial Year is not closed,Předchozí finanční rok není uzavřen
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Stáří (dny)
 DocType: Quotation Item,Quotation Item,Položka Nabídky
@@ -1825,14 +1957,15 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,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 +105,Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1
 DocType: Subscription,Reference Document,referenční dokument
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +208,{0} {1} is cancelled or stopped,{0} {1} je zrušena nebo zastavena
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +209,{0} {1} is cancelled or stopped,{0} {1} je zrušena nebo zastavena
 DocType: Accounts Settings,Credit Controller,Credit Controller
+DocType: Grant Application,Applicant Type,Typ žadatele
 DocType: Delivery Note,Vehicle Dispatch Date,Vozidlo Dispatch Datum
 DocType: Healthcare Settings,Default Medical Code Standard,Výchozí standard zdravotnického kódu
 DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +234,Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,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 +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 +113,{0}% Billed,{0}% účtovano
@@ -1841,40 +1974,44 @@
 DocType: Party Account,Party Account,Party účtu
 apps/erpnext/erpnext/config/setup.py +122,Human Resources,Lidské zdroje
 DocType: Lead,Upper Income,Horní příjmů
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +41,Reject,Odmítnout
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,Odmítnout
 DocType: Journal Entry Account,Debit in Company Currency,Debetní ve společnosti Měna
 DocType: BOM Item,BOM Item,Položka kusovníku
 DocType: Appraisal,For Employee,Pro zaměstnance
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Udělat vyplácení Entry
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Řádek {0}: Advance proti dodavatelem musí být odepsat
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Supplier must be debit,Řádek {0}: Advance proti dodavatelem musí být odepsat
 DocType: Company,Default Values,Výchozí hodnoty
+DocType: Membership,INR,INR
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Frekvence} Digest
 DocType: Expense Claim,Total Amount Reimbursed,Celkové částky proplacené
 apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,To je založeno na protokolech proti tomuto vozidlu. Viz časovou osu níže podrobnosti
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
 DocType: Customer,Default Price List,Výchozí Ceník
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +244,Asset Movement record {0} created,Záznam Asset Pohyb {0} vytvořil
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +265,Asset Movement record {0} created,Záznam Asset Pohyb {0} vytvořil
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Nelze odstranit fiskální rok {0}. Fiskální rok {0} je nastaven jako výchozí v globálním nastavení
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Zákazník se stejným jménem již existuje
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +183,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Tím bude předkládán výplatní pásky a vytvářet záznamy časového rozvrhu. Chcete pokračovat?
+DocType: Purchase Invoice,Total Net Weight,Celková čistá hmotnost
 DocType: Journal Entry,Entry Type,Entry Type
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,V této hodnotící skupině není spojen žádný plán hodnocení
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,V této hodnotící skupině není spojen žádný plán hodnocení
 ,Customer Credit Balance,Zákazník Credit Balance
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Čistá Změna účty závazků
 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 +148,Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
+apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Stanovení ceny
 DocType: Quotation,Term Details,Termín Podrobnosti
-DocType: Project,Total Sales Cost (via Sales Order),Celkové prodejní náklady (prostřednictvím objednávky prodeje)
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Nemůže přihlásit více než {0} studentů na této studentské skupiny.
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Nemůže přihlásit více než {0} studentů na této studentské skupiny.
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Počet vedoucích
-apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} musí být větší než 0
+apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} musí být větší než 0
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +17,Stock Available,Skladem k dispozici
 DocType: Manufacturing Settings,Capacity Planning For (Days),Plánování kapacit Pro (dny)
 apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Procurement
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,None of the items have any change in quantity or value.,Žádný z těchto položek má žádnou změnu v množství nebo hodnotě.
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Povinná oblast - Program
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Povinná oblast - Program
 DocType: Special Test Template,Result Component,Komponent výsledků
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Záruční reklamace
 ,Lead Details,Detaily leadu
+DocType: Volunteer,Availability and Skills,Dostupnost a dovednosti
 DocType: Salary Slip,Loan repayment,splácení úvěru
 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
@@ -1885,14 +2022,14 @@
 DocType: Shipping Rule Country,Shipping Rule Country,Přepravní Pravidlo Země
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Nechat docházky
 DocType: Maintenance Visit,Partially Completed,Částečně Dokončeno
-apps/erpnext/erpnext/healthcare/setup.py +256,Moderate Sensitivity,Mírná citlivost
+apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Mírná citlivost
 DocType: Leave Type,Include holidays within leaves as leaves,Zahrnout dovolenou v listech jsou listy
 DocType: Sales Invoice,Packed Items,Zabalené položky
 apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Reklamační proti sériového čísla
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +65,'Total',&#39;Celkový&#39;
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +71,'Total',&#39;Celkový&#39;
 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 +260,"Advance paid against {0} {1} cannot be greater \
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +258,"Advance paid against {0} {1} cannot be greater \
 						than Grand Total {2}",Vyplacena záloha proti {0} {1} nemůže být větší \ než Grand Celkem {2}
 DocType: Patient,Medication,Léky
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,"Prosím, vyberte položku kód"
@@ -1903,36 +2040,42 @@
 DocType: Purchase Invoice,Additional Discount,Další slevy
 DocType: Selling Settings,Selling Settings,Prodejní Nastavení
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Potvrďte akci
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +39,Online Auctions,Aukce online
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Aukce online
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +98,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/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,Splnění
 apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Zobrazit Košík
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Marketingové náklady
 ,Item Shortage Report,Položka Nedostatek Report
-apps/erpnext/erpnext/stock/doctype/item/item.js +279,"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 +275,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnost je uvedeno, \n uveďte prosím ""váha UOM"" příliš"
 DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Zadaný požadavek materiálu k výrobě této skladové karty
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Vedle Odpisy Datum je povinné pro nové aktivum
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Vedle Odpisy Datum je povinné pro nové aktivum
 DocType: Student Group Creation Tool,Separate course based Group for every Batch,Samostatná skupina založená na kurzu pro každou dávku
 apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Single jednotka položky.
 DocType: Fee Category,Fee Category,poplatek Kategorie
+DocType: Agriculture Task,Next Business Day,Následující pracovní den
+DocType: Customer,Primary Contact Detail,Primární kontaktní detail
 DocType: Drug Prescription,Dosage by time interval,Dávkování podle časového intervalu
 ,Student Fee Collection,Student Fee Collection
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Délka schůzky (min)
 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/purchase_invoice/purchase_invoice.py +160,Warehouse required at Row No {0},Warehouse vyžadováno při Row No {0}
-apps/erpnext/erpnext/public/js/setup_wizard.js +139,Please enter valid Financial Year Start and End Dates,Zadejte prosím platnou finanční rok datum zahájení a ukončení
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Warehouse vyžadováno při Row No {0}
+apps/erpnext/erpnext/public/js/setup_wizard.js +142,Please enter valid Financial Year Start and End Dates,Zadejte prosím platnou finanční rok datum zahájení a ukončení
 DocType: Employee,Date Of Retirement,Datum odchodu do důchodu
 DocType: Upload Attendance,Get Template,Získat šablonu
 DocType: Material Request,Transferred,Přestoupil
 DocType: Vehicle,Doors,dveře
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +196,ERPNext Setup Complete!,ERPNext Setup Complete!
+apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,ERPNext Setup Complete!
 DocType: Healthcare Settings,Collect Fee for Patient Registration,Vybírat poplatek za registraci pacienta
+apps/erpnext/erpnext/stock/doctype/item/item.py +650,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Atributy nelze změnit po transakci akcií. Vytvořte novou položku a přeneste materiál do nové položky
 DocType: Course Assessment Criteria,Weightage,Weightage
 DocType: Purchase Invoice,Tax Breakup,Rozdělení daní
 DocType: Packing Slip,PS-,PS-
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Je zapotřebí nákladového střediska pro &#39;zisku a ztráty &quot;účtu {2}. Prosím nastavit výchozí nákladového střediska pro společnost.
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +118,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Zákaznická Skupina existuje se stejným názvem, prosím změňte název zákazníka nebo přejmenujte skupinu zákazníků"
+DocType: Member,Non Profit Member,Neziskový člen
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,"{0} {1}: Je vyžadováno nákladové středisko pro 'zisk a ztráta ""účtu {2}. Prosím nastavte výchozí nákladové středisko pro společnost."
+DocType: Payment Schedule,Payment Term,Platební termín
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +146,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Zákaznická Skupina existuje se stejným názvem, prosím změňte název zákazníka nebo přejmenujte skupinu zákazníků"
+DocType: Land Unit,Area,Plocha
 apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Nový kontakt
 DocType: Territory,Parent Territory,Parent Territory
 DocType: Sales Invoice,Place of Supply,Místo dodávky
@@ -1942,39 +2085,40 @@
 DocType: Announcement,Instructor,Instruktor
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Vyberte položku (volitelné)
 DocType: Fee Schedule Student Group,Fee Schedule Student Group,Poplatek za studentskou skupinu
-DocType: Employee,AB+,AB+
+DocType: Student,AB+,AB+
 DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Pokud je tato položka má varianty, pak to nemůže být vybrána v prodejních objednávek atd"
 DocType: Lead,Next Contact By,Další Kontakt By
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +311,Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +314,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 +46,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
 ,Item-wise Sales Register,Item-moudrý Sales Register
 DocType: Asset,Gross Purchase Amount,Gross Částka nákupu
 apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Počáteční zůstatky
 DocType: Asset,Depreciation Method,odpisy Metoda
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +67,Offline,Offline
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +64,Offline,Offline
 DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Celkem Target
+DocType: Soil Texture,Sand Composition (%),Složení písku (%)
 DocType: Job Applicant,Applicant for a Job,Žadatel o zaměstnání
 DocType: Production Plan Material Request,Production Plan Material Request,Výroba Poptávka Plán Materiál
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Žádné výrobní zakázky vytvořené
 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: Purchase Invoice Item,Batch No,Č. šarže
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +141,Request for Quotation: {0},Žádost o nabídku: {0}
 DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Povolit více Prodejní objednávky proti Zákazníka Objednávky
 DocType: Student Group Instructor,Student Group Instructor,Instruktor skupiny studentů
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile Žádné
-apps/erpnext/erpnext/setup/doctype/company/company.py +197,Main,Hlavní
-apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant,Varianta
+DocType: Grant Application,Assessment  Mark (Out of 10),Známka hodnocení (z 10)
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile Žádné
+apps/erpnext/erpnext/setup/doctype/company/company.py +194,Main,Hlavní
+apps/erpnext/erpnext/stock/doctype/item/item.js +72,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,zaměstnanci HTML
-apps/erpnext/erpnext/stock/doctype/item/item.py +428,Default BOM ({0}) must be active for this item or its template,Výchozí BOM ({0}) musí být aktivní pro tuto položku nebo jeho šablony
+apps/erpnext/erpnext/stock/doctype/item/item.py +444,Default BOM ({0}) must be active for this item or its template,Výchozí BOM ({0}) musí být aktivní pro tuto položku nebo jeho šablony
 DocType: Employee,Leave Encashed?,Dovolená proplacena?
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Opportunity Ze hřiště je povinné
 DocType: Email Digest,Annual Expenses,roční náklady
 DocType: Item,Variants,Varianty
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1088,Make Purchase Order,Proveďte objednávky
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1137,Make Purchase Order,Proveďte objednávky
 DocType: SMS Center,Send To,Odeslat
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,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
@@ -1982,36 +2126,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 +177,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 +197,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
 DocType: Item,Serial Nos and Batches,Sériové čísla a dávky
-apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Síla skupiny studentů
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Síla skupiny studentů
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +250,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,ocenění
+apps/erpnext/erpnext/config/hr.py +142,Appraisals,ocenění
 apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Školení
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,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/hr/doctype/employee/employee.py +161,Please enter ,Prosím Vstupte
-apps/erpnext/erpnext/controllers/accounts_controller.py +423,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Nelze overbill k bodu {0} v řadě {1} více než {2}. Aby bylo možné přes-fakturace, je třeba nastavit při nákupu Nastavení"
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +212,Please set filter based on Item or Warehouse,Prosím nastavit filtr na základě výtisku nebo ve skladu
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,Prosím Vstupte
+apps/erpnext/erpnext/controllers/accounts_controller.py +467,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Nelze overbill k bodu {0} v řadě {1} více než {2}. Aby bylo možné přes-fakturace, je třeba nastavit při nákupu Nastavení"
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Protokol údržby
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +234,Please set filter based on Item or Warehouse,Prosím nastavit filtr na základě výtisku nebo ve skladu
 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,Dodat a Bill
 DocType: Student Group,Instructors,instruktoři
 DocType: GL Entry,Credit Amount in Account Currency,Kreditní Částka v měně účtu
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +584,BOM {0} must be submitted,BOM {0} musí být předloženy
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +588,BOM {0} must be submitted,BOM {0} musí být předloženy
 DocType: Authorization Control,Authorization Control,Autorizace Control
-apps/erpnext/erpnext/controllers/buying_controller.py +308,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Řádek # {0}: Zamítnutí Warehouse je povinná proti zamítnuté bodu {1}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Payment,Platba
+apps/erpnext/erpnext/controllers/buying_controller.py +309,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Řádek # {0}: Zamítnutí Warehouse je povinná proti zamítnuté bodu {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Payment,Platba
 apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Warehouse {0} není propojen s žádným účtem, uveďte prosím účet v záznamu skladu nebo nastavte výchozí inventární účet ve firmě {1}."
 apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Správa objednávek
 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: Crop,Crop Spacing,Rozdělení oříznutí
 DocType: Course,Course Abbreviation,Zkratka hřiště
 DocType: Student Leave Application,Student Leave Application,Student nechat aplikaci
 DocType: Item,Will also apply for variants,Bude platit i pro varianty
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Asset nelze zrušit, protože je již {0}"
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Asset nelze zrušit, protože je již {0}"
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Zaměstnanec {0} na půl dne na {1}
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Celkem pracovní doba by neměla být větší než maximální pracovní doby {0}
 apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Kdy
@@ -2021,9 +2167,9 @@
 DocType: Quality Inspection Reading,Reading 10,Čtení 10
 DocType: Hub Category,Hub Node,Hub Node
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,"Zadali jste duplicitní položky. Prosím, opravu a zkuste to znovu."
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +125,Associate,Spolupracovník
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Spolupracovník
 DocType: Asset Movement,Asset Movement,Asset Movement
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2165,New Cart,New košík
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2180,New Cart,New koší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: SMS Center,Create Receiver List,Vytvořit přijímače seznam
 DocType: Vehicle,Wheels,kola
@@ -2034,18 +2180,21 @@
 DocType: Activity Cost,Activity Cost,Náklady Aktivita
 DocType: Sales Invoice Timesheet,Timesheet Detail,časového rozvrhu Detail
 DocType: Purchase Receipt Item Supplied,Consumed Qty,Spotřeba Množství
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +52,Telecommunications,Telekomunikace
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Telekomunikace
+apps/erpnext/erpnext/accounts/party.py +266,Billing currency must be equal to either default company's currency or party account currency,Měna fakturace se musí rovnat buď měně výchozí měny nebo měně stran účtu
 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: Soil Texture,Loam,Hlína
+apps/erpnext/erpnext/controllers/accounts_controller.py +680,Row {0}: Due Date cannot be before posting date,Řádek {0}: K datu splatnosti nemůže být datum odeslání
 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 +129,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/templates/emails/recurring_document_failed.html +3,For,Pro
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +150,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"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/payment_entry/payment_entry.js +167,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,Sklad pro příjem
-apps/erpnext/erpnext/config/accounts.py +249,Tree of financial Cost Centers.,Strom Nákl.střediska finančních.
+apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Strom Nákl.střediska finančních.
 DocType: Serial No,Delivery Document No,Dodávka dokument č
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Prosím nastavte &quot;/ ZTRÁTY zisk z aktiv odstraňováním&quot; ve firmě {0}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Prosím nastavte &quot;/ ZTRÁTY zisk z aktiv odstraňováním&quot; ve firmě {0}
 DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Položka získaná z dodacího listu
 DocType: Serial No,Creation Date,Datum vytvoření
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Položka {0} se objeví několikrát v Ceníku {1}
@@ -2058,19 +2207,20 @@
 apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Aktualizace odpovědi
 apps/erpnext/erpnext/public/js/utils.js +226,You have already selected items from {0} {1},Již jste vybrané položky z {0} {1}
 DocType: Monthly Distribution,Name of the Monthly Distribution,Název měsíční výplatou
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +25,Batch ID is mandatory,Číslo šarže je povinné
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +26,Batch ID is mandatory,Číslo šarže je povinné
 DocType: Sales Person,Parent Sales Person,Parent obchodník
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +180,High to Low,Vysoká až nízká
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +24,Select the program first,Nejprve vyberte program
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Nejprve vyberte program
 DocType: Patient Appointment,Patient Age,Věk pacienta
 apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Správa projektů
 DocType: Supplier,Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
 DocType: Budget,Fiscal Year,Fiskální rok
+DocType: Asset Maintenance Log,Planned,Plánováno
 DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,"Standardní pohledávky, které mají být použity, pokud nejsou nastaveny v Pacientovi pro rezervaci konzultačních poplatků."
 DocType: Vehicle Log,Fuel Price,palivo Cena
 DocType: Budget,Budget,Rozpočet
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +43,Set Open,Nastavit Otevřít
-apps/erpnext/erpnext/stock/doctype/item/item.py +245,Fixed Asset Item must be a non-stock item.,Fixed Asset položky musí být non-skladová položka.
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Nastavit Otevřít
+apps/erpnext/erpnext/stock/doctype/item/item.py +247,Fixed Asset Item must be a non-stock item.,Fixed Asset položky musí být non-skladová položka.
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Rozpočet nelze přiřadit proti {0}, protože to není výnos nebo 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á
 DocType: Student Admission,Application Form Route,Přihláška Trasa
@@ -2084,12 +2234,13 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,"Položka {0} není nastavení pro Serial č. Zkontrolujte, zda master položku"
 DocType: Maintenance Visit,Maintenance Time,Údržba Time
 ,Amount to Deliver,"Částka, která má dodávat"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +321,Same item has been entered multiple times. {0},Stejná položka byla zadána několikrát. {0}
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termínovaný Datum zahájení nemůže být dříve než v roce datum zahájení akademického roku, ke kterému termín je spojena (akademický rok {}). Opravte data a zkuste to znovu."
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Same item has been entered multiple times. {0},Stejná položka byla zadána několikrát. {0}
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termínovaný Datum zahájení nemůže být dříve než v roce datum zahájení akademického roku, ke kterému termín je spojena (akademický rok {}). Opravte data a zkuste to znovu."
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +192,There were errors.,Byly tam chyby.
 DocType: Guardian,Guardian Interests,Guardian Zájmy
 DocType: Naming Series,Current Value,Current Value
-apps/erpnext/erpnext/controllers/accounts_controller.py +240,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Několik fiskálních let existují pro data {0}. Prosím nastavte společnost ve fiskálním roce
-DocType: School Settings,Instructor Records to be created by,"Záznamy instruktorů, které mají být vytvořeny"
+apps/erpnext/erpnext/controllers/accounts_controller.py +263,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Několik fiskálních let existují pro data {0}. Prosím nastavte společnost ve fiskálním roce
+DocType: Education Settings,Instructor Records to be created by,"Záznamy instruktorů, které mají být vytvořeny"
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} vytvořil
 DocType: Delivery Note Item,Against Sales Order,Proti přijaté objednávce
 ,Serial No Status,Serial No Status
@@ -2101,19 +2252,20 @@
  musí být větší než nebo rovno {2}"
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,To je založeno na akciovém pohybu. Viz {0} Podrobnosti
 DocType: Pricing Rule,Selling,Prodejní
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +378,Amount {0} {1} deducted against {2},Množství {0} {1} odečíst proti {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +379,Amount {0} {1} deducted against {2},Množství {0} {1} odečíst proti {2}
 DocType: Employee,Salary Information,Vyjednávání o platu
 DocType: Sales Person,Name and Employee ID,Jméno a ID zaměstnance
-apps/erpnext/erpnext/accounts/party.py +310,Due Date cannot be before Posting Date,Datum splatnosti nesmí být před odesláním Datum
+apps/erpnext/erpnext/accounts/party.py +311,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 +150,Duties and Taxes,Odvody a daně
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,"Prosím, zadejte Referenční den"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Please enter Reference date,"Prosím, zadejte Referenční den"
 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} platební položky nelze filtrovat přes {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žství
 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/payment_entry/payment_entry.js +160,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: Payroll Entry,Get Employee Details,Získejte podrobnosti o zaměstnancích
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,Cannot refer row number greater than or equal to current row number for this Charge type,Nelze odkazovat číslo řádku větší nebo rovnou aktuální číslo řádku pro tento typ Charge
 DocType: Asset,Sold,Prodáno
 ,Item-wise Purchase History,Item-moudrý Historie nákupů
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,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}"
@@ -2125,7 +2277,7 @@
 DocType: Sales Invoice,Accounting Details,Účetní detaily
 apps/erpnext/erpnext/setup/doctype/company/company.js +84,Delete all the Transactions for this Company,Odstraňte všechny transakce pro tuto společnost
 DocType: Patient,O Positive,O pozitivní
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +190,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: 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/stock/doctype/stock_entry/stock_entry.py +195,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: 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 +68,Investments,Investice
 DocType: Issue,Resolution Details,Rozlišení Podrobnosti
 apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,alokace
@@ -2137,6 +2289,7 @@
 DocType: Employee Loan Application,Total Payable Amount,Celková částka Splatné
 DocType: Task,Expected Time (in hours),Předpokládaná doba (v hodinách)
 DocType: Item Reorder,Check in (group),Check in (skupina)
+DocType: Soil Texture,Silt,Silt
 ,Qty to Order,Množství k objednávce
 DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Účet hlavu pod závazkem nebo vlastním kapitálem, ve kterém budou Zisk / ztráta rezervovat"
 apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Ganttův diagram všech zadaných úkolů.
@@ -2146,7 +2299,7 @@
 DocType: Course,Default Grading Scale,Výchozí Klasifikační stupnice
 DocType: Appraisal,For Employee Name,Pro jméno zaměstnance
 DocType: Holiday List,Clear Table,Clear Table
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Available slots,Dostupné sloty
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Dostupné sloty
 DocType: C-Form Invoice Detail,Invoice No,Faktura č
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Zaplatit
 DocType: Room,Room Name,Room Jméno
@@ -2157,15 +2310,18 @@
 ,Campaign Efficiency,Efektivita kampaně
 DocType: Discussion,Discussion,Diskuse
 DocType: Payment Entry,Transaction ID,ID transakce
+DocType: Volunteer,Anytime,Kdykoliv
 DocType: Patient,Surgical History,Chirurgická historie
 DocType: Employee,Resignation Letter Date,Rezignace Letter Datum
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335,Please set the Date Of Joining for employee {0},Nastavte prosím datum zapojení pro zaměstnance {0}
 DocType: Task,Total Billing Amount (via Time Sheet),Celková částka Billing (přes Time Sheet)
 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 +175,{0} ({1}) must have role 'Expense Approver',"{0} ({1}), musí mít roli ""Schvalovatel výdajů"""
-apps/erpnext/erpnext/utilities/user_progress.py +125,Pair,Pár
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +912,Select BOM and Qty for Production,Vyberte BOM a Množství pro výrobu
+DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
+DocType: Chapter,Chapter,Kapitola
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +200,{0} ({1}) must have role 'Expense Approver',"{0} ({1}), musí mít roli ""Schvalovatel výdajů"""
+apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Pár
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +959,Select BOM and Qty for Production,Vyberte BOM a Množství pro výrobu
 DocType: Asset,Depreciation Schedule,Plán odpisy
 apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Adresy prodejních partnerů a kontakty
 DocType: Bank Reconciliation Detail,Against Account,Proti účet
@@ -2173,37 +2329,41 @@
 DocType: Maintenance Schedule Detail,Actual Date,Skutečné datum
 DocType: Item,Has Batch No,Má číslo šarže
 apps/erpnext/erpnext/public/js/utils.js +100,Annual Billing: {0},Roční Billing: {0}
-apps/erpnext/erpnext/config/accounts.py +208,Goods and Services Tax (GST India),Daň z zboží a služeb (GST India)
+apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Daň z zboží a služeb (GST India)
 DocType: Delivery Note,Excise Page Number,Spotřební Číslo stránky
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +157,"Company, From Date and To Date is mandatory","Firma, Datum od a do dnešního dne je povinná"
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +225,"Company, From Date and To Date is mandatory","Firma, Datum od a do dnešního dne je povinná"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Získejte z konzultace
 DocType: Asset,Purchase Date,Datum nákupu
-DocType: Employee,Personal Details,Osobní data
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Prosím nastavte &quot;odpisy majetku nákladové středisko&quot; ve firmě {0}
+DocType: Volunteer,Volunteer Type,Typ dobrovolníka
+DocType: Student,Personal Details,Osobní data
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Prosím nastavte &quot;odpisy majetku nákladové středisko&quot; ve firmě {0}
 ,Maintenance Schedules,Plány údržby
 DocType: Task,Actual End Date (via Time Sheet),Skutečné datum ukončení (přes Time Sheet)
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +373,Amount {0} {1} against {2} {3},Množství {0} {1} na {2} {3}
+DocType: Soil Texture,Soil Type,Typ půdy
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Amount {0} {1} against {2} {3},Množství {0} {1} na {2} {3}
 ,Quotation Trends,Uvozovky Trendy
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +159,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 +358,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,Částka - doprava
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
+DocType: Shipping Rule,Shipping Amount,Částka - doprava
 DocType: Supplier Scorecard Period,Period Score,Skóre období
 apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Přidat zákazníky
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Čeká Částka
 DocType: Lab Test Template,Special,Speciální
-DocType: Purchase Invoice Item,Conversion Factor,Konverzní faktor
+DocType: Purchase Order Item Supplied,Conversion Factor,Konverzní faktor
 DocType: Purchase Order,Delivered,Dodává
 ,Vehicle Expenses,Náklady pro auta
 DocType: Serial No,Invoice Details,Podrobnosti faktury
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},"Očekávané hodnoty po celou dobu životnosti, musí být větší než nebo rovna {0}"
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +29,Start on,Začněte dál
+DocType: Grant Application,Show on Website,Zobrazit na webu
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},"Očekávané hodnoty po celou dobu životnosti, musí být větší než nebo rovna {0}"
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Začněte dál
 DocType: Hub Category,Hub Category,Kategorie Hubu
 DocType: Purchase Invoice,SEZ,SEZ
 DocType: Purchase Receipt,Vehicle Number,Číslo vozidla
 DocType: Employee Loan,Loan Amount,Částka půjčky
+apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Přidat hlavičkový papír
 DocType: Program Enrollment,Self-Driving Vehicle,Samohybné vozidlo
 DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Dodávka tabulky dodavatelů
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +419,Row {0}: Bill of Materials not found for the Item {1},Řádek {0}: Kusovník nebyl nalezen pro výtisku {1}
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +420,Row {0}: Bill of Materials not found for the Item {1},Řádek {0}: Kusovník nebyl nalezen pro výtisku {1}
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Celkové přidělené listy {0} nemůže být nižší než již schválených listy {1} pro období
 DocType: Journal Entry,Accounts Receivable,Pohledávky
 ,Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics
@@ -2214,28 +2374,29 @@
 DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Mateřský kurz (nechte prázdné, pokud toto není součástí mateřského kurzu)"
 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ě
-apps/erpnext/erpnext/hooks.py +140,Timesheets,Timesheets
+apps/erpnext/erpnext/hooks.py +144,Timesheets,Timesheets
 DocType: HR Settings,HR Settings,Nastavení HR
 DocType: Salary Slip,net pay info,Čistý plat info
 DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Tato hodnota je aktualizována v seznamu výchozích prodejních cen.
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +111,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 +122,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: Email Digest,New Expenses,Nové výdaje
 DocType: Purchase Invoice,Additional Discount Amount,Dodatečná sleva Částka
 DocType: Consultation,Patient Details,Podrobnosti pacienta
 DocType: Patient,B Positive,B Pozitivní
-apps/erpnext/erpnext/controllers/accounts_controller.py +531,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Řádek # {0}: Množství musí být 1, když je položka investičního majetku. Prosím použít samostatný řádek pro vícenásobné Mn."
+apps/erpnext/erpnext/controllers/accounts_controller.py +575,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Řádek # {0}: Množství musí být 1, když je položka investičního majetku. Prosím použít samostatný řádek pro vícenásobné Mn."
 DocType: Leave Block List Allow,Leave Block List Allow,Nechte Block List Povolit
-apps/erpnext/erpnext/setup/doctype/company/company.py +291,Abbr can not be blank or space,Zkratka nemůže být prázdný znak nebo mezera
+apps/erpnext/erpnext/setup/doctype/company/company.py +288,Abbr can not be blank or space,Zkratka nemůže být prázdný znak nebo mezera
 DocType: Patient Medical Record,Patient Medical Record,Záznam pacienta
-apps/erpnext/erpnext/accounts/doctype/account/account.js +62,Group to Non-Group,Skupina na Non-Group
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,Sportovní
+apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Skupina na Non-Group
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Sportovní
 DocType: Loan Type,Loan Name,půjčka Name
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Celkem Aktuální
 DocType: Lab Test UOM,Test UOM,Test UOM
 DocType: Student Siblings,Student Siblings,Studentské Sourozenci
-apps/erpnext/erpnext/utilities/user_progress.py +125,Unit,Jednotka
-apps/erpnext/erpnext/stock/get_item_details.py +141,Please specify Company,"Uveďte prosím, firmu"
+apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Jednotka
+apps/erpnext/erpnext/stock/get_item_details.py +136,Please specify Company,"Uveďte prosím, firmu"
 ,Customer Acquisition and Loyalty,Zákazník Akvizice a loajality
+DocType: Asset Maintenance Task,Maintenance Task,Úloha údržby
 DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek"
 DocType: Production Order,Skip Material Transfer,Přeskočit přenos materiálu
 apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nelze najít kurz {0} až {1} pro klíčový den {2}. Ručně vytvořte záznam o směnném kurzu
@@ -2245,70 +2406,73 @@
 DocType: Issue,Support,Podpora
 ,BOM Search,Vyhledání kusovníku
 DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",Publikujte &quot;na skladě&quot; nebo &quot;není na skladě&quot; na Hubu na základě skladových zásob dostupných v tomto skladu.
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +189,Closing (Opening + Totals),Uzavření (Otevření + součty)
 DocType: Vehicle,Fuel Type,Druh paliva
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,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 +47,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,Následující materiál žádosti byly automaticky zvýšena na základě úrovni re-pořadí položky
 DocType: Email Digest,Pending Sales Orders,Čeká Prodejní objednávky
-apps/erpnext/erpnext/controllers/accounts_controller.py +279,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatný. Měna účtu musí být {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +302,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatný. Měna účtu musí být {1}
 DocType: Healthcare Settings,Remind Before,Připomenout dříve
 apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},UOM Konverzní faktor je nutné v řadě {0}
 DocType: Production Plan Item,material_request_item,material_request_item
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1034,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Řádek # {0}: Reference Document Type musí být jedním ze zakázky odběratele, prodejní faktury nebo Journal Entry"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1060,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Řádek # {0}: Reference Document Type musí být jedním ze zakázky odběratele, prodejní faktury nebo Journal Entry"
 DocType: Salary Component,Deduction,Dedukce
+DocType: Item,Retain Sample,Zachovat vzorek
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Řádek {0}: From Time a na čas je povinná.
 DocType: Stock Reconciliation Item,Amount Difference,výše Rozdíl
-apps/erpnext/erpnext/stock/get_item_details.py +306,Item Price added for {0} in Price List {1},Položka Cena přidán pro {0} v Ceníku {1}
+apps/erpnext/erpnext/stock/get_item_details.py +349,Item Price added for {0} in Price List {1},Položka Cena přidán pro {0} v Ceníku {1}
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,"Prosím, zadejte ID zaměstnance z tohoto prodeje osoby"
 DocType: Territory,Classification of Customers by region,Rozdělení zákazníků podle krajů
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +57,Difference Amount must be zero,Rozdíl Částka musí být nula
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,Ve výrobě
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +59,Difference Amount must be zero,Rozdíl Částka musí být nula
 DocType: Project,Gross Margin,Hrubá marže
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,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čtená výpis z bankovního účtu zůstatek
 DocType: Normal Test Template,Normal Test Template,Normální šablona testu
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,zakázané uživatelské
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +764,Quotation,Nabídka
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +957,Cannot set a received RFQ to No Quote,Nelze nastavit přijatou RFQ na Žádnou nabídku
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +913,Quotation,Nabídka
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +982,Cannot set a received RFQ to No Quote,Nelze nastavit přijatou RFQ na Žádnou nabídku
 DocType: Quotation,QTN-,QTN-
 DocType: Salary Slip,Total Deduction,Celkem Odpočet
 ,Production Analytics,výrobní Analytics
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,To je založeno na transakcích proti tomuto pacientovi. Podrobnosti viz časová osa níže
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +201,Cost Updated,Náklady Aktualizováno
-DocType: Employee,Date of Birth,Datum narození
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položek&gt; Značka
+DocType: Patient,Date of Birth,Datum narození
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,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**.,** Fiskální rok ** představuje finanční rok. Veškeré účetní záznamy a další významné transakce jsou sledovány proti ** fiskální rok **.
 DocType: Opportunity,Customer / Lead Address,Zákazník / Lead Address
-DocType: Patient,DOB,DOB
 DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Nastavení tabulky dodavatelů
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Název plánu hodnocení
-apps/erpnext/erpnext/stock/doctype/item/item.py +220,Warning: Invalid SSL certificate on attachment {0},Varování: Neplatný certifikát SSL na přílohu {0}
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Název plánu hodnocení
+apps/erpnext/erpnext/stock/doctype/item/item.py +222,Warning: Invalid SSL certificate on attachment {0},Varování: Neplatný certifikát SSL na přílohu {0}
 apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Vede vám pomohou podnikání, přidejte všechny své kontakty a více jak svých potenciálních zákazníků"
 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 +226,Job Description,Popis Práce
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Job Description,Popis Práce
 DocType: Student Applicant,Applied,Aplikovaný
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +834,Re-open,Znovu otevřít
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +859,Re-open,Znovu otevřít
 DocType: Sales Invoice Item,Qty as per Stock UOM,Množství podle Stock nerozpuštěných
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Jméno Guardian2
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Jméno Guardian2
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Speciální znaky kromě ""-"". """", ""#"", a ""/"" není povoleno v pojmenování řady"
 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í
 DocType: Guardian,Work Address,pracovní adresa
 DocType: Appraisal,Calculate Total Score,Vypočítat Celková skóre
-DocType: Request for Quotation,Manufacturing Manager,Výrobní ředitel
+DocType: Asset Repair,Manufacturing Manager,Výrobní ředitel
 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 +163,Split Delivery Note into packages.,Rozdělit dodací list do balíčků.
-apps/erpnext/erpnext/hooks.py +107,Shipments,Zásilky
+DocType: Plant Analysis Criteria,Minimum Permissible Value,Minimální přípustná hodnota
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +42,User {0} already exists,Uživatel {0} již existuje
+apps/erpnext/erpnext/hooks.py +109,Shipments,Zásilky
 DocType: Payment Entry,Total Allocated Amount (Company Currency),Celková alokovaná částka (Company měna)
 DocType: Purchase Order Item,To be delivered to customer,Chcete-li být doručeno zákazníkovi
 DocType: BOM,Scrap Material Cost,Šrot Material Cost
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,"Pořadové číslo {0} nepatří do skladu,"
+DocType: Grant Application,Email Notification Sent,Zasláno oznámení o e-mailu
 DocType: Purchase Invoice,In Words (Company Currency),Slovy (měna společnosti)
-DocType: Asset,Supplier,Dodavatel
+DocType: Pricing Rule,Supplier,Dodavatel
 DocType: Consultation,Consultation Time,Doba konzultace
 DocType: C-Form,Quarter,Čtvrtletí
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Různé výdaje
@@ -2321,112 +2485,120 @@
 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 se nepodařilo odeslat pro zdravotně postižené uživatele
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Počet interakcí
-apps/erpnext/erpnext/stock/doctype/item/item.js +102,Item Variant Settings,Nastavení varianty položky
+apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Nastavení varianty položky
 apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,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 +223,"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 +424,{0} is mandatory for Item {1},{0} je povinná k položce {1}
-DocType: Process Payroll,Fortnightly,Čtrnáctidenní
+apps/erpnext/erpnext/config/hr.py +228,"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 +428,{0} is mandatory for Item {1},{0} je povinná k položce {1}
+DocType: Payroll Entry,Fortnightly,Čtrnáctidenní
 DocType: Currency Exchange,From Currency,Od Měny
 DocType: Vital Signs,Weight (In Kilogram),Hmotnost (v kilogramech)
+DocType: Chapter,"chapters/chapter_name
+leave blank automatically set after saving chapter.",kapitoly / název_kapitoly nechte prázdné pole automaticky po uložení kapitoly.
 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/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +125,Cost of New Purchase,Náklady na nový nákup
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Náklady na nový nákup
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0}
+DocType: Grant Application,Grant Description,Grant Popis
 DocType: Purchase Invoice Item,Rate (Company Currency),Cena (Měna Společnosti)
 DocType: Student Guardian,Others,Ostatní
 DocType: Payment Entry,Unallocated Amount,nepřidělené Částka
 apps/erpnext/erpnext/templates/includes/product_page.js +71,Cannot find a matching Item. Please select some other value for {0}.,Nelze najít odpovídající položku. Vyberte nějakou jinou hodnotu pro {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/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosím, nastavte systém pro pojmenování zaměstnanců v oblasti lidských zdrojů&gt; Nastavení HR"
 apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Žádné další aktualizace
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +154,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,"Toto pokrývá všechny body, které jsou spojeny s tímto nastavením"
 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,Dítě Položka by neměla být produkt Bundle. Odeberte položku `{0}` a uložit
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Bankovnictví
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Bankovnictví
 apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Přidat Timesheets
 DocType: Vehicle Service,Service Item,servis Položka
 DocType: Bank Guarantee,Bank Guarantee,Bankovní záruka
 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"
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +56,There were errors while deleting following schedules:,Došlo k chybám během odstraňování tohoto schématu:
 DocType: Bin,Ordered Quantity,Objednané množství
-apps/erpnext/erpnext/public/js/setup_wizard.js +115,"e.g. ""Build tools for builders""","např ""Stavět nástroje pro stavitele """
+apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","např ""Stavět nástroje pro stavitele """
 DocType: Grading Scale,Grading Scale Intervals,Třídění dílků
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Účetní Vstup pro {2} mohou být prováděny pouze v měně: {3}
-DocType: Production Order,In Process,V procesu
+DocType: Fee Schedule,In Process,V procesu
 DocType: Authorization Rule,Itemwise Discount,Itemwise Sleva
 apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Strom finančních účtů.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} proti Prodejní objednávce {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +362,{0} against Sales Order {1},{0} proti Prodejní objednávce {1}
 DocType: Account,Fixed Asset,Základní Jmění
 apps/erpnext/erpnext/config/stock.py +320,Serialized Inventory,Serialized Zásoby
 DocType: Employee Loan,Account Info,Informace o účtu
 DocType: Activity Type,Default Billing Rate,Výchozí fakturace Rate
 DocType: Fees,Include Payment,Zahrnout platbu
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Studentské skupiny byly vytvořeny.
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Studentské skupiny byly vytvořeny.
 DocType: Sales Invoice,Total Billing Amount,Celková částka fakturace
 apps/erpnext/erpnext/hr/doctype/daily_work_summary_settings/daily_work_summary_settings.py +17,There must be a default incoming Email Account enabled for this to work. Please setup a default incoming Email Account (POP/IMAP) and try again.,Musí existovat výchozí příchozí e-mailový účet povolen pro tuto práci. Prosím nastavit výchozí příchozí e-mailový účet (POP / IMAP) a zkuste to znovu.
-DocType: Healthcare Settings,Receivable Account,Účet pohledávky
-apps/erpnext/erpnext/controllers/accounts_controller.py +553,Row #{0}: Asset {1} is already {2},Řádek # {0}: Asset {1} je již {2}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Program ve struktuře poplatků a studentské skupině {0} jsou různé.
+DocType: Fee Schedule,Receivable Account,Účet pohledávky
+apps/erpnext/erpnext/controllers/accounts_controller.py +597,Row #{0}: Asset {1} is already {2},Řádek # {0}: Asset {1} je již {2}
 DocType: Quotation Item,Stock Balance,Reklamní Balance
 apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Prodejní objednávky na platby
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +119,CEO,výkonný ředitel
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,výkonný ředitel
 DocType: Purchase Invoice,With Payment of Tax,S platbou daně
 DocType: Expense Claim Detail,Expense Claim Detail,Detail úhrady výdajů
 DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLICATE PRO DODAVATELE
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +868,Please select correct account,"Prosím, vyberte správný účet"
-DocType: Item,Weight UOM,Hmotnostní jedn.
+DocType: Land Unit,Is Container,Je kontejner
+DocType: Crop Cycle,This will be day 1 of the crop cycle,Bude to první den cyklu plodin
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +869,Please select correct account,"Prosím, vyberte správný účet"
+DocType: Purchase Invoice Item,Weight UOM,Hmotnostní jedn.
 DocType: Salary Structure Employee,Salary Structure Employee,Plat struktura zaměstnanců
-DocType: Patient,Blood Group,Krevní Skupina
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Zobrazit atributy variantu
+DocType: Student,Blood Group,Krevní Skupina
 DocType: Course,Course Name,Název kurzu
 DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Uživatelé, kteří si vyhoví žádosti konkrétního zaměstnance volno"
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Kancelářské Vybavení
 DocType: Purchase Invoice Item,Qty,Množství
 DocType: Fiscal Year,Companies,Společnosti
 DocType: Supplier Scorecard,Scoring Setup,Nastavení bodování
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +24,Electronics,Elektronika
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronika
 DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Zvýšit Materiál vyžádání při stock dosáhne úrovně re-order
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +94,Full-time,Na plný úvazek
-DocType: Salary Structure,Employees,zaměstnanci
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Na plný úvazek
+DocType: Payroll Entry,Employees,zaměstnanci
 DocType: Employee,Contact Details,Kontaktní údaje
 DocType: C-Form,Received Date,Datum přijetí
 DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Pokud jste vytvořili standardní šablonu v prodeji daní a poplatků šablony, vyberte jednu a klikněte na tlačítko níže."
 DocType: BOM Scrap Item,Basic Amount (Company Currency),Základní částka (Company měna)
 DocType: Student,Guardians,Guardians
 DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Ceny nebude zobrazeno, pokud Ceník není nastaven"
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +28,Please specify a country for this Shipping Rule or check Worldwide Shipping,"Uveďte prosím zemi, k tomuto Shipping pravidla nebo zkontrolovat Celosvětová doprava"
 DocType: Stock Entry,Total Incoming Value,Celková hodnota Příchozí
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +352,Debit To is required,Debetní K je vyžadováno
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +356,Debit To is required,Debetní K je vyžadováno
 apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets pomůže udržet přehled o času, nákladů a účtování pro aktivit hotový svého týmu"
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Nákupní Ceník
 apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Šablony proměnných tabulky dodavatelů dodavatelů.
 DocType: Offer Letter Term,Offer Term,Nabídka Term
-DocType: Quality Inspection,Quality Manager,Manažer kvality
+DocType: Asset,Quality Manager,Manažer kvality
 DocType: Job Applicant,Job Opening,Job Zahájení
 DocType: Payment Reconciliation,Payment Reconciliation,Platba Odsouhlasení
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,"Prosím, vyberte incharge jméno osoby"
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +51,Technology,Technologie
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Technologie
 DocType: Hub Settings,Unregister from Hub,Zrušte registraci z Hubu
 apps/erpnext/erpnext/public/js/utils.js +102,Total Unpaid: {0},Celkové nezaplacené: {0}
 DocType: BOM Website Operation,BOM Website Operation,BOM Webové stránky Provoz
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Nabídka 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.
 DocType: Supplier Scorecard,Supplier Score,Skóre dodavatele
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +76,Total Invoiced Amt,Celkové fakturované Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +87,Total Invoiced Amt,Celkové fakturované Amt
 DocType: Supplier,Warn RFQs,Upozornění na RFQ
 DocType: BOM,Conversion Rate,Míra konverze
 apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Hledat výrobek
-DocType: Physician Schedule Time Slot,To Time,Chcete-li čas
+DocType: Assessment Plan,To Time,Chcete-li čas
 DocType: Authorization Rule,Approving Role (above authorized value),Schválení role (nad oprávněné hodnoty)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Payable account,Připsat na účet musí být Splatnost účet
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,"Vyberte studentský vstup, který je povinný pro žáka placeného studenta"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335,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 +118,Credit To account must be a Payable account,Připsat na účet musí být Splatnost účet
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,"Vyberte studentský vstup, který je povinný pro žáka placeného studenta"
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +338,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/hub_node/doctype/hub_settings/hub_settings.py +23,Please select a Price List to publish pricing,Vyberte ceník pro publikování cen
+apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Rozpočtový seznam
 DocType: Production Order Operation,Completed Qty,Dokončené Množství
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"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/accounts/doctype/journal_entry/journal_entry.py +146,"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/doctype/item_price/item_price.py +27,Price List {0} is disabled,Ceník {0} je zakázána
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Řádek {0}: Dokončené Množství nemůže být více než {1} pro provoz {2}
 DocType: Manufacturing Settings,Allow Overtime,Povolit Přesčasy
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serializovaná položka {0} nemůže být aktualizována pomocí odsouhlasení akcií, použijte prosím položku Stock"
 DocType: Training Event Employee,Training Event Employee,Vzdělávání zaměstnanců Event
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +976,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maximální počet vzorků - {0} lze zadat pro dávky {1} a položku {2}.
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Přidat časové úseky
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Sériová čísla požadované pro položky {1}. Poskytli jste {2}.
 DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuální ocenění
@@ -2443,10 +2615,13 @@
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,"Další nákladová střediska mohou být vyrobeny v rámci skupiny, ale položky mohou být provedeny proti non-skupin"
 apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Uživatelé a oprávnění
 DocType: Vehicle Log,VLOG.,Vlog.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +945,Production Orders Created: {0},Výrobní zakázky Vytvořeno: {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +994,Production Orders Created: {0},Výrobní zakázky Vytvořeno: {0}
 DocType: Branch,Branch,Větev
+DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
+DocType: Delivery Trip,Fulfillment User,Uživatel splnění požadavků
 apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Tisk a identita
 DocType: Company,Total Monthly Sales,Celkový měsíční prodej
+DocType: Agriculture Analysis Criteria,Weather,Počasí
 DocType: Bin,Actual Quantity,Skutečné Množství
 DocType: Shipping Rule,example: Next Day Shipping,Příklad: Next Day Shipping
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Pořadové číslo {0} nebyl nalezen
@@ -2455,15 +2630,16 @@
 DocType: Fee Schedule Program,Student Batch,Student Batch
 apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Udělat Student
 DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
-apps/erpnext/erpnext/projects/doctype/project/project.py +203,You have been invited to collaborate on the project: {0},Byli jste pozváni ke spolupráci na projektu: {0}
+apps/erpnext/erpnext/projects/doctype/project/project.py +214,You have been invited to collaborate on the project: {0},Byli jste pozváni ke spolupráci na projektu: {0}
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Physician not available on {0},Lékař není k dispozici na {0}
 DocType: Leave Block List Date,Block Date,Block Datum
+DocType: Crop,Crop,Oříznutí
 DocType: Purchase Receipt,Supplier Delivery Note,Dodávka Dodavatelská poznámka
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +70,Apply Now,Použít teď
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Použít teď
 apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Aktuální počet {0} / Čekací počet {1}
 DocType: Purchase Invoice,E-commerce GSTIN,E-commerce GSTIN
 DocType: Sales Order,Not Delivered,Ne vyhlášeno
-apps/erpnext/erpnext/controllers/buying_controller.py +421,Expected Date cannot be before Transaction Date,Předpokládaný datum nemůže být před datem transakce
+apps/erpnext/erpnext/controllers/buying_controller.py +422,Expected Date cannot be before Transaction Date,Předpokládaný datum nemůže být před datem transakce
 ,Bank Clearance Summary,Souhrn bankovního zúčtování
 apps/erpnext/erpnext/config/setup.py +106,"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
@@ -2472,21 +2648,23 @@
 DocType: Fee Schedule,Fee Structure,Struktura poplatků
 DocType: Timesheet Detail,Costing Amount,Kalkulace Částka
 DocType: Student Admission Program,Application Fee,poplatek za podání žádosti
-DocType: Process Payroll,Submit Salary Slip,Odeslat výplatní pásce
-apps/erpnext/erpnext/controllers/selling_controller.py +165,Maxiumm discount for Item {0} is {1}%,Maxiumm sleva na položky {0} {1}%
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,Submit Salary Slip,Odeslat výplatní pásce
+apps/erpnext/erpnext/controllers/selling_controller.py +133,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 hromadnou
 DocType: Sales Partner,Address & Contacts,Adresa a kontakty
 DocType: SMS Log,Sender Name,Jméno odesílatele
+DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Kritéria analýzy zemědělství
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +193,Sort by Criteria,Řadit podle kritérií
 DocType: POS Profile,[Select],[Vybrat]
 DocType: Vital Signs,Blood Pressure (diastolic),Krevní tlak (diastolický)
 DocType: SMS Log,Sent To,Odeslána
+DocType: Agriculture Task,Holiday Management,Správa prázdnin
 DocType: Payment Request,Make Sales Invoice,Proveďte prodejní faktuře
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,Programy
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +50,Next Contact Date cannot be in the past,Následující Kontakt datum nemůže být v minulosti
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,Next Contact Date cannot be in the past,Následující Kontakt datum nemůže být v minulosti
 DocType: Company,For Reference Only.,Pouze orientační.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +91,Physician {0} not available on {1},Lékař {0} není dostupný v {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2519,Select Batch No,Vyberte číslo šarže
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Lékař {0} není dostupný v {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2538,Select Batch No,Vyberte číslo šarže
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},Neplatný {0}: {1}
 DocType: Purchase Invoice,PINV-RET-,PInv-RET-
 DocType: Fee Validity,Reference Inv,Odkaz Inv
@@ -2498,12 +2676,12 @@
 DocType: Employee,Employment Details,Informace o zaměstnání
 DocType: Employee,New Workplace,Nové pracoviště
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Nastavit jako Zavřeno
-apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Barcode {0},No Položka s čárovým kódem {0}
+apps/erpnext/erpnext/stock/get_item_details.py +125,No Item with Barcode {0},No Položka s čárovým kódem {0}
 DocType: Normal Test Items,Require Result Value,Požadovat hodnotu výsledku
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Případ č nemůže být 0
 DocType: Item,Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +514,Boms,kusovníky
-apps/erpnext/erpnext/stock/doctype/item/item.py +149,Stores,Zásoba
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +517,Boms,kusovníky
+apps/erpnext/erpnext/stock/doctype/item/item.py +151,Stores,Zásoba
 DocType: Project Type,Projects Manager,Správce projektů
 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
@@ -2518,17 +2696,19 @@
 DocType: Rename Tool,Rename Tool,Přejmenování
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Aktualizace nákladů
 DocType: Item Reorder,Item Reorder,Položka Reorder
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +446,Show Salary Slip,Show výplatní pásce
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +823,Transfer Material,Přenos materiálu
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Show výplatní pásce
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +848,Transfer Material,Přenos materiálu
 DocType: Fees,Send Payment Request,Odeslat žádost o platbu
 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."
+DocType: Water Analysis,Origin,Původ
 apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Tento dokument je nad hranicí {0} {1} pro položku {4}. Děláte si jiný {3} proti stejné {2}?
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1006,Please set recurring after saving,Prosím nastavte opakující se po uložení
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +758,Select change amount account,Vybrat změna výše účet
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1086,Please set recurring after saving,Prosím nastavte opakující se po uložení
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +763,Select change amount account,Vybrat změna výše účet
 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
+DocType: Soil Texture,Clay,Jíl
 DocType: Topic,Topic,Téma
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Peněžní tok z finanční
 DocType: Budget Account,Budget Account,rozpočet účtu
@@ -2537,34 +2717,38 @@
 DocType: Grading Scale Interval,Grade Description,Grade Popis
 DocType: Stock Entry,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/stock/doctype/item/item_dashboard.py +34,Traceability,sledovatelnost
+DocType: Asset Maintenance Log,Actions performed,Akce byly provedeny
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +381,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/stock/doctype/stock_entry/stock_entry.py +406,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
 DocType: Supplier Scorecard Scoring Standing,Employee,Zaměstnanec
+DocType: Asset Repair,Failure Date,Datum selhání
 DocType: Sample Collection,Collected Time,Shromážděný čas
 DocType: Company,Sales Monthly History,Měsíční historie prodeje
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +204,Select Batch,Vyberte možnost Dávka
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} je plně fakturováno
+DocType: Asset Maintenance Task,Next Due Date,Další datum splatnosti
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Vyberte možnost Dávka
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +242,{0} {1} is fully billed,{0} {1} je plně fakturováno
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +48,Vital Signs,Známky života
 DocType: Training Event,End Time,End Time
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Aktivní Struktura Plat {0} nalezeno pro zaměstnance {1} pro uvedené termíny
 DocType: Payment Entry,Payment Deductions or Loss,Platební srážky nebo ztráta
+DocType: Soil Analysis,Soil Analysis Criterias,Kritéria analýzy půdy
 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 +100,Group by Voucher,Seskupit podle Poukazu
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +186,Are you sure you want to cancel this appointment?,Opravdu chcete tuto schůzku zrušit?
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Opravdu chcete tuto schůzku zrušit?
 apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,prodejní Pipeline
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +216,Please set default account in Salary Component {0},Prosím nastavit výchozí účet platu Component {0}
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},Prosím nastavit výchozí účet platu Component {0}
 apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Povinné On
 DocType: Rename Tool,File to Rename,Soubor k přejmenování
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},"Prosím, vyberte BOM pro položku v řádku {0}"
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Účet {0} neodpovídá společnosti {1} v účtu účtu: {2}
-apps/erpnext/erpnext/controllers/buying_controller.py +270,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 +221,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/controllers/buying_controller.py +271,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
+DocType: Soil Texture,Sandy Loam,Sandy Loam
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí být zrušena před zrušením této prodejní objednávky
 DocType: POS Profile,Applicable for Users,Platí pro uživatele
 DocType: Notification Control,Expense Claim Approved,Uhrazení výdajů schváleno
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,Salary Slip of employee {0} already created for this period,Výplatní pásce zaměstnance {0} již vytvořili pro toto období
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +151,Pharmaceutical,Farmaceutické
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,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:
@@ -2574,76 +2758,76 @@
 DocType: Supplier Scorecard,Warn for new Purchase Orders,Upozornit na nové nákupní objednávky
 DocType: Quality Inspection Reading,Reading 9,Čtení 9
 DocType: Supplier,Is Frozen,Je Frozen
-apps/erpnext/erpnext/stock/utils.py +217,Group node warehouse is not allowed to select for transactions,Uzel skupina sklad není dovoleno vybrat pro transakce
+apps/erpnext/erpnext/stock/utils.py +222,Group node warehouse is not allowed to select for transactions,Uzel skupina sklad není dovoleno vybrat pro transakce
 DocType: Buying Settings,Buying Settings,Nákup Nastavení
 DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce
 DocType: Upload Attendance,Attendance To Date,Účast na data
 DocType: Request for Quotation Supplier,No Quote,Žádná citace
 DocType: Warranty Claim,Raised By,Vznesené
 DocType: Payment Gateway Account,Payment Account,Platební účet
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +880,Please specify Company to proceed,Uveďte prosím společnost pokračovat
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +906,Please specify Company to proceed,Uveďte prosím společnost pokračovat
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Čistá změna objemu pohledávek
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Compensatory Off,Vyrovnávací Off
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Vyrovnávací Off
 DocType: Offer Letter,Accepted,Přijato
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,Organizace
+DocType: Grant Application,Organization,Organizace
 DocType: BOM Update Tool,BOM Update Tool,Nástroj pro aktualizaci kusovníku
-apps/erpnext/erpnext/accounts/party.py +204,"Party account not specified, please setup default party account in company","Party účet není zadán, prosím nastavte výchozí účet ve společnosti"
 DocType: SG Creation Tool Course,Student Group Name,Jméno Student Group
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Vytváření poplatků
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Vytváření poplatků
 apps/erpnext/erpnext/setup/doctype/company/company.js +62,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Ujistěte se, že opravdu chcete vymazat všechny transakce pro tuto společnost. Vaše kmenová data zůstanou, jak to je. Tuto akci nelze vrátit zpět."
 DocType: Room,Room Number,Číslo pokoje
 apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Neplatná reference {0} {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +167,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemůže být větší, než plánované množství ({2}), ve výrobní objednávce {3}"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemůže být větší, než plánované množství ({2}), ve výrobní objednávce {3}"
 DocType: Shipping Rule,Shipping Rule Label,Přepravní Pravidlo Label
+DocType: Journal Entry Account,Payroll Entry,Příspěvek mzdy
 apps/erpnext/erpnext/public/js/conf.js +28,User Forum,User Forum
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +305,Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +488,"Could not update stock, invoice contains drop shipping item.","Nelze aktualizovat zásob, faktura obsahuje pokles lodní dopravy zboží."
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +308,Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +492,"Could not update stock, invoice contains drop shipping item.","Nelze aktualizovat zásob, faktura obsahuje pokles lodní dopravy zboží."
 DocType: Lab Test Sample,Lab Test Sample,Laboratorní testovací vzorek
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +484,Quick Journal Entry,Rychlý vstup Journal
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +492,Quick Journal Entry,Rychlý vstup Journal
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,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: Restaurant,Invoice Series Prefix,Předvolba série faktur
 DocType: Employee,Previous Work Experience,Předchozí pracovní zkušenosti
 DocType: Stock Entry,For Quantity,Pro Množství
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},"Prosím, zadejte Plánované Množství k bodu {0} na řádku {1}"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} není odesláno
-apps/erpnext/erpnext/config/stock.py +27,Requests for items.,Žádosti o položky.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +102,Google Maps integration is not enabled,Integrace Map Google není povolena
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,{0} {1} is not submitted,{0} {1} není odesláno
 DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Samostatná výrobní objednávka bude vytvořena pro každou dokončenou dobrou položku.
+DocType: Member,Membership Expiry Date,Datum ukončení členství
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} musí být negativní ve vratném dokumentu
 ,Minutes to First Response for Issues,Zápisy do první reakce na otázky
 DocType: Purchase Invoice,Terms and Conditions1,Podmínky a podmínek1
-apps/erpnext/erpnext/public/js/setup_wizard.js +106,The name of the institute for which you are setting up this system.,Název institutu pro který nastavujete tento systém.
+apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,Název institutu pro který nastavujete tento systém.
 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/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/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Poslední cena byla aktualizována ve všech kusovnících
-DocType: Fee Schedule,Successful,Úspěšný
 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 +423,The following Production Orders were created:,Následující Výrobní zakázky byly vytvořeny:
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +424,The following Production Orders were created:,Následující Výrobní zakázky byly vytvořeny:
 DocType: Student Admission Program,Naming Series (for Student Applicant),Pojmenování Series (pro studentské přihlašovatel)
 DocType: Delivery Note,Transporter Name,Přepravce Název
 DocType: Authorization Rule,Authorized Value,Autorizovaný Hodnota
 DocType: BOM,Show Operations,Zobrazit Operations
 ,Minutes to First Response for Opportunity,Zápisy do první reakce na příležitost
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Celkem Absent
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +794,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 +194,Unit of Measure,Měrná jednotka
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +823,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 +187,Unit of Measure,Měrná jednotka
 DocType: Fiscal Year,Year End Date,Datum Konce Roku
 DocType: Task Depends On,Task Depends On,Úkol je závislá na
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +999,Opportunity,Příležitost
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1024,Opportunity,Příležitost
 ,Completed Production Orders,Dokončené Výrobní zakázky
 DocType: Operation,Default Workstation,Výchozí Workstation
 DocType: Notification Control,Expense Claim Approved Message,Zpráva o schválení úhrady výdajů
 DocType: Payment Entry,Deductions or Loss,Odpočty nebo ztráta
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} je uzavřen
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +245,{0} {1} is closed,{0} {1} je uzavřen
 DocType: Email Digest,How frequently?,Jak často?
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +57,Total Collected: {0},Celkové shromáždění: {0}
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Celkové shromáždění: {0}
 DocType: Purchase Receipt,Get Current Stock,Získejte aktuální stav
 apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Strom Bill materiálů
 DocType: Student,Joining Date,Datum připojení
 ,Employees working on a holiday,Zaměstnanci pracující na dovolenou
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Současnost
 DocType: Project,% Complete Method,Dokončeno% Method
-apps/erpnext/erpnext/healthcare/setup.py +180,Drug,Lék
+apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Lék
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,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: BOM,Operating Cost (Company Currency),Provozní náklady (Company měna)
@@ -2651,12 +2835,12 @@
 DocType: Authorization Rule,Applicable To (Role),Vztahující se na (Role)
 DocType: BOM Update Tool,Replace BOM,Nahraďte kusovníku
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Kód {0} již existuje
-DocType: Stock Entry,Purpose,Účel
+DocType: Employee Advance,Purpose,Účel
 DocType: Company,Fixed Asset Depreciation Settings,Nastavení odpisování dlouhodobého majetku
 DocType: Item,Will also apply for variants unless overrridden,"Bude platit i pro varianty, pokud nebude přepsáno"
 DocType: Purchase Invoice,Advances,Zálohy
 DocType: Production Order,Manufacture against Material Request,Výroba proti Materiál Request
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Skupina hodnocení:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Skupina hodnocení:
 DocType: Item Reorder,Request for,Žádost o
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Schválení Uživatel nemůže být stejná jako uživatel pravidlo se vztahuje na
 DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Základní sazba (dle Stock nerozpuštěných)
@@ -2664,23 +2848,26 @@
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,Nechat bez nároku na odměnu nesouhlasí se schválenými záznamů nechat aplikaci
 DocType: Campaign,Campaign-.####,Kampaň-.####
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Další kroky
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +769,Please supply the specified items at the best possible rates,Prosím dodávat uvedené položky na nejlepší možné ceny
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +794,Please supply the specified items at the best possible rates,Prosím dodávat uvedené položky na nejlepší možné ceny
+DocType: Membership,USD,americký dolar
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Proveďte faktury
 DocType: Selling Settings,Auto close Opportunity after 15 days,Auto v blízkosti Příležitost po 15 dnech
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +75,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Příkazy na nákup nejsou pro {0} povoleny kvůli postavení skóre {1}.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +76,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Příkazy na nákup nejsou pro {0} povoleny kvůli postavení skóre {1}.
 apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,konec roku
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Lead%
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +119,Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování
+DocType: Driver,Driver,Řidič
 DocType: Vital Signs,Nutrition Values,Výživové hodnoty
 DocType: Lab Test Template,Is billable,Je fakturován
 DocType: Delivery Note,DN-,DN-
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}","Musí být nastaven jak &quot;Lékařský plán&quot;, tak i čas na setkání &quot;pro lékaře {0}"
 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."
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} proti nákupní objednávce {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +374,{0} against Purchase Order {1},{0} proti nákupní objednávce {1}
 DocType: Patient,Patient Demographics,Demografie pacientů
 DocType: Task,Actual Start Date (via Time Sheet),Skutečné datum zahájení (přes Time Sheet)
 apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,To je příklad webové stránky automaticky generované z ERPNext
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Stárnutí Rozsah 1
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +226,Total advance amount cannot be greater than total claimed amount,Celková výše zálohy nesmí být vyšší než celková nároková částka
 DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
 
 #### Note
@@ -2724,22 +2911,26 @@
  10. Přidat nebo odečítat: Ať už chcete přidat nebo odečíst daň."
 DocType: Homepage,Homepage,Domovská stránka
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Vyberte lékaře ...
+DocType: Grant Application,Grant Application Details ,Podrobnosti o žádosti o grant
 DocType: Purchase Receipt Item,Recd Quantity,Recd Množství
-apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +57,Fee Records Created - {0},Fee Records Vytvořil - {0}
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +59,Fee Records Created - {0},Fee Records Vytvořil - {0}
 DocType: Asset Category Account,Asset Category Account,Asset Kategorie Account
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +117,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 +539,Stock Entry {0} is not submitted,Skladový pohyb {0} není založen
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,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/stock/doctype/item/item.js +360,Select Attribute Values,Vyberte hodnoty atributů
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +537,Stock Entry {0} is not submitted,Skladový pohyb {0} není založen
 DocType: Payment Reconciliation,Bank / Cash Account,Bank / Peněžní účet
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Next Contact By cannot be same as the Lead Email Address,Následující Kontakt Tím nemůže být stejný jako hlavní e-mailovou adresu
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,Next Contact By cannot be same as the Lead Email Address,Následující Kontakt Tím nemůže být stejný jako hlavní e-mailovou adresu
 DocType: Tax Rule,Billing City,Fakturace City
 DocType: Asset,Manual,Manuál
 DocType: Salary Component Account,Salary Component Account,Účet plat Component
 DocType: Global Defaults,Hide Currency Symbol,Skrýt symbol měny
-apps/erpnext/erpnext/config/accounts.py +338,"e.g. Bank, Cash, Credit Card","např. banka, hotovost, kreditní karty"
+apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informace dárce.
+apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","např. banka, hotovost, kreditní karty"
 DocType: Lead Source,Source Name,Název zdroje
 DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Normální klidový krevní tlak u dospělého pacienta je přibližně 120 mmHg systolický a 80 mmHg diastolický, zkráceně &quot;120/80 mmHg&quot;"
 DocType: Journal Entry,Credit Note,Dobropis
 DocType: Warranty Claim,Service Address,Servisní adresy
+DocType: Asset Maintenance Task,Calibration,Kalibrace
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Nábytek a svítidla
 DocType: Item,Manufacture,Výroba
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Nastavení společnosti
@@ -2751,8 +2942,9 @@
 DocType: Opportunity,Customer / Lead Name,Zákazník / Lead Name
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Výprodej Datum není uvedeno
 apps/erpnext/erpnext/config/manufacturing.py +7,Production,Výroba
-DocType: Patient,Occupation,Povolání
+DocType: Guardian,Occupation,Povolání
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,"Row {0}: datum zahájení, musí být před koncem roku Datum"
+DocType: Crop,Planting Area,Plocha pro výsadbu
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Total (ks)
 DocType: Installation Note Item,Installed Qty,Instalované množství
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Mohlo to být způsobeno některými neplatnými e-mailovými adresami v adresáři
@@ -2762,25 +2954,25 @@
 DocType: Purchase Invoice,Is Paid,se vyplácí
 DocType: Salary Structure,Total Earning,Celkem Zisk
 DocType: Purchase Receipt,Time at which materials were received,"Čas, kdy bylo přijato materiály"
+DocType: Products Settings,Products per Page,Produkty na stránku
 DocType: Stock Ledger Entry,Outgoing Rate,Odchozí Rate
-apps/erpnext/erpnext/config/hr.py +228,Organization branch master.,Organizace větev master.
-apps/erpnext/erpnext/controllers/accounts_controller.py +280, or ,nebo
+apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Organizace větev master.
+apps/erpnext/erpnext/controllers/accounts_controller.py +303, or ,nebo
 DocType: Sales Order,Billing Status,Status Fakturace
 apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Nahlásit problém
-apps/erpnext/erpnext/public/js/setup_wizard.js +28,Education (beta),Vzdělávání (beta)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,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
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Řádek # {0}: Journal Entry {1} nemá účet {2} nebo již uzavřeno proti jinému poukazu
 DocType: Supplier Scorecard Criteria,Criteria Weight,Kritéria Váha
 DocType: Buying Settings,Default Buying Price List,Výchozí Nákup Ceník
-DocType: Process Payroll,Salary Slip Based on Timesheet,Plat Slip na základě časového rozvrhu
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +113,No employee for the above selected criteria OR salary slip already created,Žádný zaměstnanec pro výše zvolených kritérií nebo výplatní pásce již vytvořili
+DocType: Payroll Entry,Salary Slip Based on Timesheet,Plat Slip na základě časového rozvrhu
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +19,Buying Rate,Rychlost nákupu
 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"
 DocType: Payment Entry,Payment Type,Typ platby
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +131,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Vyberte položku Dávka pro položku {0}. Nelze najít jednu dávku, která splňuje tento požadavek"
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +140,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Vyberte položku Dávka pro položku {0}. Nelze najít jednu dávku, která splňuje tento požadavek"
 DocType: Hub Category,Parent Category,Rodičovská Kategorie
-DocType: Process Payroll,Select Employees,Vybrat Zaměstnanci
+DocType: Payroll Entry,Select Employees,Vybrat Zaměstnanci
 DocType: Opportunity,Potential Sales Deal,Potenciální prodej
 DocType: Complaint,Complaints,Stížnosti
 DocType: Payment Entry,Cheque/Reference Date,Šek / Referenční datum
@@ -2789,7 +2981,7 @@
 DocType: Bank Reconciliation Detail,Payment Entry,platba Entry
 DocType: Item,Quality Parameters,Parametry kvality
 ,sales-browser,Prodejní-browser
-apps/erpnext/erpnext/accounts/doctype/account/account.js +73,Ledger,Účetní kniha
+apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Účetní kniha
 DocType: Patient Medical Record,PMR-,PMR-
 DocType: Drug Prescription,Drug Code,Drogový kód
 DocType: Target Detail,Target  Amount,Cílová částka
@@ -2797,12 +2989,12 @@
 DocType: Shopping Cart Settings,Shopping Cart Settings,Nákupní košík Nastavení
 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 +29,Global POS Profile {0} already created for company {1},Global POS Profile {0} již vytvořili pro firmu {1}
+DocType: Journal Entry Account,Reference Due Date,Referenční datum splatnosti
 DocType: Purchase Order,Ref SQ,Ref SQ
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,Příjem dokument musí být předložen
 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 +320,Not Paid and Not Delivered,Nezaplatil a není doručení
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Nezaplatil a není doručení
 DocType: Product Bundle,Parent Item,Nadřazená položka
 DocType: Account,Account Type,Typ účtu
 DocType: Delivery Note,DN-RET-,DN-RET-
@@ -2811,32 +3003,35 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"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,Mzdy
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +179,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pro řádek {0} v {1}. Chcete-li v rychlosti položku jsou {2}, řádky {3} musí být také zahrnuty"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pro řádek {0} v {1}. Chcete-li v rychlosti položku jsou {2}, řádky {3} musí být také zahrnuty"
 apps/erpnext/erpnext/utilities/activation.py +101,Make User,Udělat uživatele
 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í
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Zadejte platnou e-mailovou adresu
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +654,Please select an item in the cart,Vyberte prosím položku v košíku
+DocType: Volunteer Skill,Volunteer Skill,Dobrovolnické dovednosti
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +713,Please select an item in the cart,Vyberte prosím položku v košíku
 DocType: Landed Cost Voucher,Purchase Receipt Items,Položky příjemky
 apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Přizpůsobení Formuláře
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +70,Arrear,nedoplatek
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Depreciation Amount during the period,Odpisy hodnoty v průběhu období
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,nedoplatek
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Odpisy hodnoty v průběhu období
 apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,Bezbariérový šablona nesmí být výchozí šablonu
 DocType: Account,Income Account,Účet příjmů
 DocType: Payment Request,Amount in customer's currency,Částka v měně zákazníka
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +776,Delivery,Dodávka
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +823,Delivery,Dodávka
+DocType: Volunteer,Weekdays,V pracovní dny
 DocType: Stock Reconciliation Item,Current Qty,Aktuální Množství
 DocType: Restaurant Menu,Restaurant Menu,Nabídka restaurací
 apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Předch
 DocType: Appraisal Goal,Key Responsibility Area,Key Odpovědnost Area
 apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Student Šarže pomůže sledovat docházku, posudky a poplatků pro studenty"
 DocType: Payment Entry,Total Allocated Amount,Celková alokovaná částka
-apps/erpnext/erpnext/setup/doctype/company/company.py +143,Set default inventory account for perpetual inventory,Nastavte výchozí inventář pro trvalý inventář
+apps/erpnext/erpnext/setup/doctype/company/company.py +140,Set default inventory account for perpetual inventory,Nastavte výchozí inventář pro trvalý inventář
 DocType: Item Reorder,Material Request Type,Materiál Typ požadavku
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +268,Accural Journal Entry for salaries from {0} to {1},Accural Zápis do deníku na platy od {0} do {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +824,"LocalStorage is full, did not save","Místní úložiště je plné, nezachránil"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +85,Row {0}: UOM Conversion Factor is mandatory,Řádek {0}: UOM Konverzní faktor je povinné
-apps/erpnext/erpnext/utilities/user_progress.py +214,Room Capacity,Kapacita místností
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural Zápis do deníku na platy od {0} do {1}
+apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Odeslání e-mailu o revizi grantu
+apps/erpnext/erpnext/accounts/page/pos/pos.js +839,"LocalStorage is full, did not save","Místní úložiště je plné, nezachránil"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +90,Row {0}: UOM Conversion Factor is mandatory,Řádek {0}: UOM Konverzní faktor je povinné
+apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Kapacita místností
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref
 DocType: Lab Test,LP-,LP-
 DocType: Healthcare Settings,Registration Fee,Registrační poplatek
@@ -2850,16 +3045,17 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Ceny Pravidlo je vyrobena přepsat Ceník / definovat slevy procenta, na základě určitých kritérií."
 DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Změnu skladu je možné provést pouze prostřednictvím Skladového pohybu / dodacím listem / nákupním dokladem
 DocType: Employee Education,Class / Percentage,Třída / Procento
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +130,Head of Marketing and Sales,Vedoucí marketingu a prodeje
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +68,Income Tax,Daň z příjmů
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Vedoucí marketingu a prodeje
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Daň z příjmů
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","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 +174,Track Leads by Industry Type.,Trasa vede od průmyslu typu.
+apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Přejděte na Letterheads
 DocType: Item Supplier,Item Supplier,Položka Dodavatel
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1107,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 +827,Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1187,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 +874,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,Stock Nastavení
-apps/erpnext/erpnext/accounts/doctype/account/account.py +199,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojení je možné pouze tehdy, pokud tyto vlastnosti jsou stejné v obou záznamech. Je Group, Root Type, Company"
+apps/erpnext/erpnext/accounts/doctype/account/account.py +185,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojení je možné pouze tehdy, pokud tyto vlastnosti jsou stejné v obou záznamech. Je Group, Root Type, Company"
 DocType: Vehicle,Electric,Elektrický
 DocType: Task,% Progress,% Progress
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Zisk / ztráta z aktiv likvidaci
@@ -2872,10 +3068,11 @@
 DocType: Leave Control Panel,Leave Control Panel,Ovládací panel dovolených
 DocType: Project,Task Completion,úkol Dokončení
 apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Není skladem
+DocType: Volunteer,Volunteer Skills,Dobrovolnické dovednosti
 DocType: Appraisal,HR User,HR User
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +53,POS?,POS?
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,POS?,POS?
 DocType: Purchase Invoice,Taxes and Charges Deducted,Daně a odečtené
-apps/erpnext/erpnext/hooks.py +138,Issues,Problémy
+apps/erpnext/erpnext/hooks.py +142,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}
 DocType: Sales Invoice,Debit To,Debetní K
 DocType: Restaurant Menu Item,Restaurant Menu Item,Položka nabídky restaurace
@@ -2883,60 +3080,62 @@
 DocType: Stock Ledger Entry,Actual Qty After Transaction,Skutečné Množství Po transakci
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},Žádné výplatní pásce nalezena mezi {0} a {1}
 ,Pending SO Items For Purchase Request,"Do doby, než SO položky k nákupu Poptávka"
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +35,Student Admissions,Student Přijímací
-apps/erpnext/erpnext/accounts/party.py +364,{0} {1} is disabled,{0} {1} je zakázán
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Student Přijímací
+apps/erpnext/erpnext/accounts/party.py +376,{0} {1} is disabled,{0} {1} je zakázán
 DocType: Supplier,Billing Currency,Fakturace Měna
 DocType: Sales Invoice,SINV-RET-,Sinv-RET-
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +196,Extra Large,Extra Velké
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Extra Velké
+DocType: Crop,Scientific Name,Odborný název
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Celkem Listy
 DocType: Consultation,In print,V tisku
 ,Profit and Loss Statement,Výkaz zisků a ztrát
 DocType: Bank Reconciliation Detail,Cheque Number,Šek číslo
 ,Sales Browser,Sales Browser
 DocType: Journal Entry,Total Credit,Celkový Credit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Upozornění: dalším {0} č. {1} existuje proti pohybu skladu {2}
-apps/erpnext/erpnext/utilities/user_progress_utils.py +51,Local,Místní
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +540,Warning: Another {0} # {1} exists against stock entry {2},Upozornění: dalším {0} č. {1} existuje proti pohybu skladu {2}
+apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Místní
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Úvěry a zálohy (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 +195,Large,Velký
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Velký
 DocType: Homepage Featured Product,Homepage Featured Product,Úvodní Doporučené zboží
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +236,All Assessment Groups,Všechny skupiny Assessment
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +246,All Assessment Groups,Všechny skupiny Assessment
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Název nového skladu
 apps/erpnext/erpnext/accounts/report/financial_statements.py +233,Total {0} ({1}),Celkem {0} ({1})
 DocType: C-Form Invoice Detail,Territory,Území
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
 DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +26,Fee,Poplatek
-apps/erpnext/erpnext/setup/doctype/company/company.js +124,Update in progress. It might take a while.,Aktualizace probíhá. Může chvíli trvat.
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Poplatek
+apps/erpnext/erpnext/setup/doctype/company/company.js +125,Update in progress. It might take a while.,Aktualizace probíhá. Může chvíli trvat.
 DocType: Vehicle Log,Fuel Qty,palivo Množství
 DocType: Production Order Operation,Planned Start Time,Plánované Start Time
 DocType: Course,Assessment,Posouzení
 DocType: Payment Entry Reference,Allocated,Přidělené
-apps/erpnext/erpnext/config/accounts.py +275,Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
+apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
 DocType: Student Applicant,Application Status,Stav aplikace
 DocType: Sensitivity Test Items,Sensitivity Test Items,Položky testu citlivosti
 DocType: Fees,Fees,Poplatky
 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 +158,Quotation {0} is cancelled,Nabídka {0} je zrušena
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Nabídka {0} je zrušena
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Celková dlužná částka
 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.
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +199,Please create Customer from Lead {0},Prosím vytvořte Zákazník z olova {0}
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Prosím vytvořte Zákazník z olova {0}
 apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Vyberte pacienta
 DocType: Price List,Applicable for Countries,Pro země
 DocType: Supplier Scorecard Scoring Variable,Parameter Name,Název parametru
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,"Nechte pouze aplikace, které mají status &quot;schváleno&quot; i &quot;Zamítnuto&quot; může být předložena"
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Student Název skupiny je povinné v řadě {0}
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Student Název skupiny je povinné v řadě {0}
 DocType: Homepage,Products to be shown on website homepage,"Produkty, které mají být uvedeny na internetových stránkách domovské"
 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: Employee,AB-,AB-
+DocType: Student,AB-,AB-
 DocType: POS Profile,Ignore Pricing Rule,Ignorovat Ceny pravidlo
 DocType: Employee Education,Graduate,Absolvent
 DocType: Leave Block List,Block Days,Blokové dny
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","Odeslání adresy nemá zemi, která je požadována pro toto Pravidlo plavby"
 DocType: Journal Entry,Excise Entry,Spotřební Entry
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +64,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozornění: prodejní objednávky {0} již existuje proti Zákazníka Objednávky {1}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozornění: prodejní objednávky {0} již existuje proti Zákazníka Objednávky {1}
 DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
 
 Examples:
@@ -2962,54 +3161,56 @@
  1. Podmínky přepravy, v případě potřeby.
  1. Způsoby řešení sporů, náhrady škody, odpovědnosti za škodu, atd 
  1. Adresa a kontakt na vaši společnost."
+DocType: Issue,Issue Type,Typ vydání
 DocType: Attendance,Leave Type,Typ absence
 DocType: Purchase Invoice,Supplier Invoice Details,Dodavatel fakturační údaje
+DocType: Agriculture Task,Ignore holidays,Ignorovat svátky
 apps/erpnext/erpnext/controllers/stock_controller.py +233,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: Project,Copied From,Zkopírován z
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Název chyba: {0}
 apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Shortage,Nedostatek
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not associated with {2} {3},{0} {1} není spojeno s {2} {3}
 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)
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Nastavte výchozího zákazníka v nastavení restaurace
 ,Salary Register,plat Register
 DocType: Warehouse,Parent Warehouse,Nadřízený sklad
 DocType: C-Form Invoice Detail,Net Total,Net Total
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +498,Default BOM not found for Item {0} and Project {1},Výchozí kusovník nebyl nalezen pro položku {0} a projekt {1}
-apps/erpnext/erpnext/config/hr.py +163,Define various loan types,Definovat různé typy půjček
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +526,Default BOM not found for Item {0} and Project {1},Výchozí kusovník nebyl nalezen pro položku {0} a projekt {1}
+apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Definovat různé typy půjček
 DocType: Bin,FCFS Rate,FCFS Rate
-DocType: Payment Reconciliation Invoice,Outstanding Amount,Dlužné částky
+DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Dlužné částky
 apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Čas (v min)
 DocType: Project Task,Working,Pracovní
 DocType: Stock Ledger Entry,Stock Queue (FIFO),Sklad fronty (FIFO)
-apps/erpnext/erpnext/public/js/setup_wizard.js +124,Financial Year,Finanční rok
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +41,{0} does not belong to Company {1},{0} nepatří do Společnosti {1}
+apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Finanční rok
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} nepatří do Společnosti {1}
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,"Nelze vyřešit funkci skóre kritérií pro {0}. Zkontrolujte, zda je vzorec platný."
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +119,Cost as on,Stát jak na
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Stát jak na
 DocType: Healthcare Settings,Out Patient Settings,Out Nastavení pacienta
 DocType: Account,Round Off,Zaokrouhlit
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +231,Quantity must be positive,Množství musí být kladné
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +252,Quantity must be positive,Množství musí být kladné
 ,Requested Qty,Požadované množství
 DocType: Tax Rule,Use for Shopping Cart,Použití pro Košík
 apps/erpnext/erpnext/controllers/item_variant.py +96,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Hodnota {0} atributu {1} neexistuje v seznamu platného bodu Hodnoty atributů pro položky {2}
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +78,Select Serial Numbers,Zvolte sériová čísla
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Zvolte sériová čísla
 DocType: BOM Item,Scrap %,Scrap%
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","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 +111,Atleast one item should be entered with negative quantity in return document,Aspoň jedna položka by měla být zadána s negativním množství ve vratném dokumentu
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Provoz {0} déle, než všech dostupných pracovních hodin v pracovní stanici {1}, rozložit provoz do několika operací"
+DocType: Membership,Membership Status,Stav členství
 ,Requested,Požadované
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,No Remarks,Žádné poznámky
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Žádné poznámky
+DocType: Asset,In Maintenance,V údržbě
 DocType: Purchase Invoice,Overdue,Zpožděný
 DocType: Account,Stock Received But Not Billed,Sklad nepřijali Účtovaný
-apps/erpnext/erpnext/accounts/doctype/account/account.py +87,Root Account must be a group,Root účet musí být skupina
+apps/erpnext/erpnext/accounts/doctype/account/account.py +86,Root Account must be a group,Root účet musí být skupina
 DocType: Consultation,Drug Prescription,Předepisování léků
 DocType: Fees,FEE.,POPLATEK.
 DocType: Employee Loan,Repaid/Closed,Splacena / Zavřeno
 DocType: Item,Total Projected Qty,Celková předpokládaná Množství
 DocType: Monthly Distribution,Distribution Name,Distribuce Name
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Dodavatel&gt; Typ dodavatele
-apps/erpnext/erpnext/stock/stock_ledger.py +464,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Hodnota ocenění nebyla nalezena u položky {0}, která je povinna provést účetní záznamy za {1} {2}. Pokud položka transakce probíhá jako položka s nulovou hodnotou v {1}, uveďte ji v tabulce {1} položky. V opačném případě prosím vytvořte příchozí akciovou transakci pro položku nebo zmiňte ohodnocení v záznamu o položce a zkuste odeslat / zrušit tuto položku"
+apps/erpnext/erpnext/stock/stock_ledger.py +471,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Hodnota ocenění nebyla nalezena u položky {0}, která je povinna provést účetní záznamy za {1} {2}. Pokud položka transakce probíhá jako položka s nulovou hodnotou v {1}, uveďte ji v tabulce {1} položky. V opačném případě prosím vytvořte příchozí akciovou transakci pro položku nebo zmiňte ohodnocení v záznamu o položce a zkuste odeslat / zrušit tuto položku"
 DocType: Course,Course Code,Kód předmětu
 apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},Kontrola kvality potřebný k bodu {0}
 DocType: POS Settings,Use POS in Offline Mode,Používejte POS v režimu offline
@@ -3020,20 +3221,20 @@
 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
-apps/erpnext/erpnext/accounts/page/pos/pos.js +484,Please select Apply Discount On,"Prosím, vyberte Použít Sleva na"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +497,Please select Apply Discount On,"Prosím, vyberte Použít Sleva na"
+DocType: Stock Settings,Sample Retention Warehouse,Úložiště uchovávání vzorků
 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: Physician,Physician Schedule,Lékařský rozvrh
 DocType: Purchase Invoice,Deemed Export,Považován za export
 DocType: Stock Entry,Material Transfer for Manufacture,Materiál Přenos: Výroba
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Sleva v procentech lze použít buď proti Ceníku nebo pro všechny Ceníku.
 DocType: Subscription,Half-yearly,Pololetní
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +402,Accounting Entry for Stock,Účetní položka na skladě
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +406,Accounting Entry for Stock,Účetní položka na skladě
 DocType: Lab Test,LabTest Approver,Nástroj LabTest
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Již jste hodnotili kritéria hodnocení {}.
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Již jste hodnotili kritéria hodnocení {}.
 DocType: Vehicle Service,Engine Oil,Motorový olej
 DocType: Sales Invoice,Sales Team1,Sales Team1
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +39,Item {0} does not exist,Bod {0} neexistuje
+apps/erpnext/erpnext/stock/doctype/item/item.py +521,Item {0} does not exist,Bod {0} neexistuje
 DocType: Sales Invoice,Customer Address,Zákazník Address
 DocType: Employee Loan,Loan Details,půjčka Podrobnosti
 DocType: Company,Default Inventory Account,Výchozí účet inventáře
@@ -3041,6 +3242,7 @@
 DocType: Antibiotic,Antibiotic Name,Název antibiotika
 DocType: Purchase Invoice,Apply Additional Discount On,Použít dodatečné Sleva na
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Vyberte typ ...
+DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,"Spojení se všemi pozemními jednotkami, ve kterých rostou"
 DocType: Account,Root Type,Root Type
 DocType: Item,FIFO,FIFO
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Řádek # {0}: Nelze vrátit více než {1} pro bodu {2}
@@ -3048,21 +3250,23 @@
 DocType: Item Group,Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky
 DocType: BOM,Item UOM,Položka UOM
 DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Částka daně po slevě Částka (Company měny)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +150,Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +155,Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
 DocType: Cheque Print Template,Primary Settings,primární Nastavení
 DocType: Purchase Invoice,Select Supplier Address,Vybrat Dodavatel Address
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +380,Add Employees,Přidejte Zaměstnanci
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Přidejte Zaměstnanci
 DocType: Purchase Invoice Item,Quality Inspection,Kontrola kvality
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +192,Extra Small,Extra Malé
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Extra Malé
 DocType: Company,Standard Template,standardní šablona
 DocType: Training Event,Theory,Teorie
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +780,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/stock/doctype/material_request/material_request.js +805,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 +211,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/doctype/payment_entry/payment_entry.py +689,Can only make payment against unbilled {0},Lze provést pouze platbu proti nevyfakturované {0}
-apps/erpnext/erpnext/controllers/selling_controller.py +130,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Potraviny, nápoje a tabák"
+DocType: Account,Account Number,Číslo účtu
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +714,Can only make payment against unbilled {0},Lze provést pouze platbu proti nevyfakturované {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +98,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
+DocType: Volunteer,Volunteer,Dobrovolník
 DocType: Stock Entry,Subcontract,Subdodávka
 apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,"Prosím, zadejte {0} jako první"
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +87,No replies from,Žádné odpovědi od
@@ -3071,60 +3275,68 @@
 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: Crop,Crop Name,Název plodiny
 DocType: SMS Log,No of Sent SMS,Počet odeslaných SMS
 DocType: Antibiotic,Healthcare Administrator,Správce zdravotní péče
 apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Nastavte cíl
 DocType: Dosage Strength,Dosage Strength,Síla dávkování
 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 +199,Colour,Barevné
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Software
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Barevné
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Plan Assessment Criteria
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zabránit nákupním objednávkám
-apps/erpnext/erpnext/healthcare/setup.py +257,Susceptible,Citlivý
+apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,Citlivý
 DocType: Patient Appointment,Scheduled,Plánované
 apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Žádost o cenovou nabídku.
 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 skladem,&quot; je &quot;Ne&quot; a &quot;je Sales Item&quot; &quot;Ano&quot; a není tam žádný jiný produkt Bundle"
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Vyberte zákazníka
 DocType: Student Log,Academic,Akademický
 DocType: Patient,Personal and Social History,Osobní a sociální historie
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +52,User {0} created,Uživatel {0} byl vytvořen
 DocType: Fee Schedule,Fee Breakup for each student,Rozdělení poplatků za každého studenta
-apps/erpnext/erpnext/controllers/accounts_controller.py +476,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celková záloha ({0}) na objednávku {1} nemůže být větší než celkový součet ({2})
+apps/erpnext/erpnext/controllers/accounts_controller.py +520,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celková záloha ({0}) na objednávku {1} nemůže být větší než celkový součet ({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ů.
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Změnit kód
 DocType: Purchase Invoice Item,Valuation Rate,Ocenění
 DocType: Stock Reconciliation,SR/,SR /
 DocType: Vehicle,Diesel,motorová nafta
-apps/erpnext/erpnext/stock/get_item_details.py +338,Price List Currency not selected,Ceníková Měna není zvolena
+apps/erpnext/erpnext/stock/get_item_details.py +381,Price List Currency not selected,Ceníková Měna není zvolena
 apps/erpnext/erpnext/config/healthcare.py +46,Results,výsledky
 ,Student Monthly Attendance Sheet,Student měsíční návštěvnost Sheet
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Pravidlo plavby platí pouze pro prodej
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,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 +5,Until,Dokud
 DocType: Rename Tool,Rename Log,Přejmenovat Přihlásit
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Studentská skupina nebo program je povinný
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Studentská skupina nebo program je povinný
 DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Udržovat fakturace hodin a pracovní doby stejný na časový rozvrh
 DocType: Maintenance Visit Purpose,Against Document No,Proti dokumentu č
 DocType: BOM,Scrap,Šrot
-apps/erpnext/erpnext/utilities/user_progress.py +196,Go to Instructors,Přejděte na instruktory
+apps/erpnext/erpnext/utilities/user_progress.py +214,Go to Instructors,Přejděte na instruktory
 apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Správa prodejních partnerů.
 DocType: Quality Inspection,Inspection Type,Kontrola Type
 DocType: Fee Validity,Visited yet,Ještě navštěvováno
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Sklady se stávajícími transakce nelze převést na skupinu.
 DocType: Assessment Result Tool,Result HTML,výsledek HTML
+apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Memeber Activity,Aktivita členů
 apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,vyprší dne
 apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Přidejte studenty
+apps/erpnext/erpnext/public/js/utils.js +264,Please select {0},"Prosím, vyberte {0}"
 DocType: C-Form,C-Form No,C-Form No
 DocType: BOM,Exploded_items,Exploded_items
-apps/erpnext/erpnext/utilities/user_progress.py +118,List your products or services that you buy or sell.,"Seznamte své produkty nebo služby, které kupujete nebo prodáváte."
+apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,"Seznamte své produkty nebo služby, které kupujete nebo prodáváte."
+DocType: Water Analysis,Storage Temperature,Skladovací teplota
 DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačené Návštěvnost
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +133,Researcher,Výzkumník
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Výzkumník
 DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Registrace do programu Student Tool
+apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Datum zahájení by mělo být menší než datum ukončení úkolu {0}
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Jméno nebo e-mail je povinné
-apps/erpnext/erpnext/config/stock.py +168,Incoming quality inspection.,Vstupní kontrola jakosti.
 DocType: Purchase Order Item,Returned Qty,Vrácené Množství
-DocType: Employee,Exit,Východ
-apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Root Type is mandatory,Root Type je povinné
+DocType: Student,Exit,Východ
+apps/erpnext/erpnext/accounts/doctype/account/account.py +158,Root Type is mandatory,Root Type je povinné
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Instalace předvoleb se nezdařila
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} v současné době disponuje {1} hodnotící tabulkou dodavatelů a RFQ tohoto dodavatele by měla být vydána s opatrností.
+DocType: Chapter,Non Profit Manager,Neziskový manažer
 DocType: BOM,Total Cost(Company Currency),Celkové náklady (Company měna)
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,Pořadové číslo {0} vytvořil
 DocType: Homepage,Company Description for website homepage,Společnost Popis pro webové stránky domovskou stránku
@@ -3135,40 +3347,41 @@
 DocType: Employee,You can enter any date manually,Můžete zadat datum ručně
 DocType: Healthcare Settings,Result Printed,Tiskový výsledek
 DocType: Asset Category Account,Depreciation Expense Account,Odpisy Náklady účtu
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +221,Probationary Period,Zkušební doba
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Probationary Period,Zkušební doba
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Zobrazit {0}
 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 +136,Row {0}: Advance against Customer must be credit,Řádek {0}: Advance proti zákazník musí být úvěr
-apps/erpnext/erpnext/accounts/doctype/account/account.js +83,Non-Group to Group,Non-skupiny ke skupině
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Dávka je povinná v řádku {0}
+DocType: Project,Total Costing Amount (via Timesheets),Celková částka kalkulování (prostřednictvím časových lístků)
+DocType: Employee Advance,Expense Approver,Schvalovatel výdajů
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +134,Row {0}: Advance against Customer must be credit,Řádek {0}: Advance proti zákazník musí být úvěr
+apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Non-skupiny ke skupině
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Dávka je povinná v řádku {0}
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané
 DocType: Payment Entry,Pay,Zaplatit
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Chcete-li datetime
-apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +54,Course Schedules deleted:,Plány kurzu zrušuje:
 apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Protokoly pro udržení stavu doručení sms
 DocType: Accounts Settings,Make Payment via Journal Entry,Provést platbu přes Journal Entry
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +86,Printed On,Vytištěno na
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +97,Printed On,Vytištěno na
 DocType: Item,Inspection Required before Delivery,Inspekce Požadované před porodem
 DocType: Item,Inspection Required before Purchase,Inspekce Požadované před nákupem
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Nevyřízené Aktivity
 DocType: Patient Appointment,Reminded,Připomenuto
 DocType: Patient,PID-,PID-
-apps/erpnext/erpnext/public/js/setup_wizard.js +103,Your Organization,Vaše organizace
+DocType: Chapter Member,Chapter Member,Člen kapitoly
+apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Vaše organizace
 DocType: Fee Component,Fees Category,Kategorie poplatky
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Please enter relieving date.,Zadejte zmírnění datum.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Zadejte zmírnění datum.
 apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
 DocType: Supplier Scorecard,Notify Employee,Upozornit zaměstnance
 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,Vydavatelé novin
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Vydavatelé novin
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Vyberte Fiskální rok
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +114,Expected Delivery Date should be after Sales Order Date,Očekávaný termín dodání by měl být po datu objednávky
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,Očekávaný termín dodání by měl být po datu objednávky
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Změna pořadí Level
 DocType: Company,Chart Of Accounts Template,Účtový rozvrh šablony
 DocType: Attendance,Attendance Date,Účast Datum
-apps/erpnext/erpnext/stock/get_item_details.py +302,Item Price updated for {0} in Price List {1},Položka Cena aktualizován pro {0} v Ceníku {1}
+apps/erpnext/erpnext/stock/get_item_details.py +345,Item Price updated for {0} in Price List {1},Položka Cena aktualizován pro {0} v Ceníku {1}
 DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +131,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 +130,Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu
 DocType: Purchase Invoice Item,Accepted Warehouse,Schválený sklad
 DocType: Bank Reconciliation Detail,Posting Date,Datum zveřejnění
 DocType: Item,Valuation Method,Metoda ocenění
@@ -3177,15 +3390,15 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +85,Duplicate entry,Duplicitní záznam
 DocType: Program Enrollment Tool,Get Students,Získat studenty
 DocType: Serial No,Under Warranty,V rámci záruky
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +491,[Error],[Chyba]
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +515,[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/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Zvolte datum dokončení dokončené opravy
 DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Student Batch Účast Tool
 apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,Limit zkříženými
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Naplánováno až
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,Venture Capital
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademický termín s tímto &quot;akademický rok &#39;{0} a&quot; Jméno Termín&#39; {1} již existuje. Upravte tyto položky a zkuste to znovu.
-apps/erpnext/erpnext/stock/doctype/item/item.py +474,"As there are existing transactions against item {0}, you can not change the value of {1}",Stejně jako existují nějaké transakce proti položce {0} nelze změnit hodnotu {1}
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Naplánováno až
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Venture Capital
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademický termín s tímto &quot;akademický rok &#39;{0} a&quot; Jméno Termín&#39; {1} již existuje. Upravte tyto položky a zkuste to znovu.
 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)
 DocType: Purchase Invoice,Invoice Copy,Kopie faktury
@@ -3195,7 +3408,7 @@
 DocType: Payment Reconciliation Invoice,Invoice Number,Číslo faktury
 DocType: Shopping Cart Settings,Orders,Objednávky
 DocType: Employee Leave Approver,Leave Approver,Schvalovatel absenece
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +272,Please select a batch,Vyberte dávku
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,Vyberte dávku
 DocType: Assessment Group,Assessment Group Name,Název skupiny Assessment
 DocType: Manufacturing Settings,Material Transferred for Manufacture,Převádí jaderný materiál pro Výroba
 DocType: Expense Claim,"A user with ""Expense Approver"" role","Uživatel s rolí ""Schvalovatel výdajů"""
@@ -3204,21 +3417,23 @@
 ,Issued Items Against Production Order,Vydané předmětů proti výrobní zakázky
 DocType: Antibiotic,Healthcare,Zdravotní péče
 DocType: Target Detail,Target Detail,Target Detail
+apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Jediný variant
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Všechny Jobs
 DocType: Sales Order,% of materials billed against this Sales Order,% materiálů fakturovaných proti této prodejní obědnávce
 DocType: Program Enrollment,Mode of Transportation,Způsob dopravy
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Období Uzávěrka Entry
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Vyberte oddělení ...
 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
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +360,Amount {0} {1} {2} {3},Množství {0} {1} {2} {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +361,Amount {0} {1} {2} {3},Množství {0} {1} {2} {3}
 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,Docházky zaměstnanců Tool
 DocType: Guardian Student,Guardian Student,Guardian Student
 DocType: Supplier,Credit Limit,Úvěrový limit
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Průměrné Míra prodejních cen
 DocType: Production Plan Sales Order,Salse Order Date,Salse Datum objednávky
 DocType: Salary Component,Salary Component,plat Component
-apps/erpnext/erpnext/accounts/utils.py +490,Payment Entries {0} are un-linked,Platební Příspěvky {0} jsou un-spojený
+apps/erpnext/erpnext/accounts/utils.py +492,Payment Entries {0} are un-linked,Platební Příspěvky {0} jsou un-spojený
 DocType: GL Entry,Voucher No,Voucher No
 ,Lead Owner Efficiency,Vedoucí účinnost vlastníka
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +195,Most Popular,Nejoblíbenější
@@ -3231,12 +3446,12 @@
 apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Šablona podmínek nebo smlouvy.
 DocType: Purchase Invoice,Address and Contact,Adresa a Kontakt
 DocType: Cheque Print Template,Is Account Payable,Je účtu splatný
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +273,Stock cannot be updated against Purchase Receipt {0},Sklad nelze aktualizovat proti dokladu o koupi {0}
-DocType: Supplier,Last Day of the Next Month,Poslední den následujícího měsíce
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Sklad nelze aktualizovat proti dokladu o koupi {0}
+DocType: Company,Last Day of the Next Month,Poslední den následujícího měsíce
 DocType: Support Settings,Auto close Issue after 7 days,Auto v blízkosti Issue po 7 dnech
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Dovolená nemůže být přiděleny před {0}, protože rovnováha dovolené již bylo carry-předávány v budoucí přidělení dovolenou záznamu {1}"
-apps/erpnext/erpnext/accounts/party.py +319,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/schools/doctype/program/program.js +8,Student Applicant,Student Žadatel
+apps/erpnext/erpnext/accounts/party.py +320,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/education/doctype/program/program.js +8,Student Applicant,Student Žadatel
 DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINÁL PRO PŘÍJEMCE
 DocType: Asset Category Account,Accumulated Depreciation Account,Účet oprávek
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Tento e-mail je automaticky generován
@@ -3247,38 +3462,41 @@
 DocType: Activity Cost,Billing Rate,Fakturace Rate
 ,Qty to Deliver,Množství k dodání
 ,Stock Analytics,Stock Analytics
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +505,Operations cannot be left blank,Operace nemůže být prázdné
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +508,Operations cannot be left blank,Operace nemůže být prázdné
 DocType: Maintenance Visit Purpose,Against Document Detail No,Proti Detail dokumentu č
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +98,Party Type is mandatory,Typ strana je povinná
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +99,Party Type is mandatory,Typ strana je povinná
 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/buying_controller.py +395,{0} {1} is cancelled or closed,{0} {1} je zrušen nebo zavřené
+apps/erpnext/erpnext/controllers/buying_controller.py +396,{0} {1} is cancelled or closed,{0} {1} je zrušen nebo zavřené
+DocType: Asset,Calculate Depreciation,Vypočítat odpisy
 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 +30,Net Cash from Investing,Čistý peněžní tok z investiční
 DocType: Production Order,Work-in-Progress Warehouse,Work-in-Progress sklad
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} musí být předloženy
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} musí být předloženy
 DocType: Fee Schedule Program,Total Students,Celkem studentů
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Účast Record {0} existuje proti Student {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Reference # {0} ze dne {1}
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +161,Depreciation Eliminated due to disposal of assets,Odpisy vypadl v důsledku nakládání s majetkem
+apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Účast Record {0} existuje proti Student {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +352,Reference #{0} dated {1},Reference # {0} ze dne {1}
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Odpisy vypadl v důsledku nakládání s majetkem
+DocType: Member,Member,Člen
 apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Správa adres
-DocType: Asset,Item Code,Kód položky
+DocType: Pricing Rule,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
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Vyberte studenty ručně pro skupinu založenou na aktivitách
+apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Vyberte studenty ručně pro skupinu založenou na aktivitách
 DocType: Journal Entry,User Remark,Uživatel Poznámka
 DocType: Lead,Market Segment,Segment trhu
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +924,Paid Amount cannot be greater than total negative outstanding amount {0},Zaplacená částka nemůže být vyšší než celkový negativní dlužné částky {0}
+DocType: Crop,Agriculture Manager,Zemědělský manažer
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},Zaplacená částka nemůže být vyšší než celkový negativní dlužné částky {0}
 DocType: Supplier Scorecard Period,Variables,Proměnné
 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 +239,Closing (Dr),Uzavření (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Dr),Uzavření (Dr)
 DocType: Cheque Print Template,Cheque Size,Šek Velikost
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,Pořadové číslo {0} není skladem
 apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Daňové šablona na prodej transakce.
 DocType: Sales Invoice,Write Off Outstanding Amount,Odepsat dlužné částky
 apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Účet {0} neodpovídá společnosti {1}
-DocType: School Settings,Current Academic Year,Aktuální akademický rok
+DocType: Education Settings,Current Academic Year,Aktuální akademický rok
 DocType: Stock Settings,Default Stock UOM,Výchozí Skladem UOM
 DocType: Asset,Number of Depreciations Booked,Počet Odpisy rezervováno
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Proti zaměstnanců úvěru: {0}
@@ -3286,49 +3504,54 @@
 DocType: Production Planning Tool,Create Material Requests,Vytvořit požadavek na materiál
 DocType: Employee Education,School/University,Škola / University
 DocType: Payment Request,Reference Details,Odkaz Podrobnosti
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Očekávaná hodnota Po celou dobu životnosti musí být menší než Gross částky nákupu
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Očekávaná hodnota Po celou dobu životnosti musí být menší než Gross částky nákupu
 DocType: Sales Invoice Item,Available Qty at Warehouse,Množství k dispozici na skladu
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Fakturovaná částka
 DocType: Asset,Double Declining Balance,Double degresivní
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +179,Closed order cannot be cancelled. Unclose to cancel.,Uzavřená objednávka nemůže být zrušen. Otevřít zrušit.
-DocType: Patient Relation,Father,Otec
-apps/erpnext/erpnext/controllers/accounts_controller.py +562,'Update Stock' cannot be checked for fixed asset sale,&quot;Aktualizace Sklad&quot; nemohou být kontrolovány na pevnou prodeji majetku
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Uzavřená objednávka nemůže být zrušen. Otevřít zrušit.
+DocType: Student Guardian,Father,Otec
+apps/erpnext/erpnext/controllers/accounts_controller.py +606,'Update Stock' cannot be checked for fixed asset sale,"""Aktualizace Sklad"" nemohou být zaškrtnuty na prodej dlouhodobého majetku"
 DocType: Bank Reconciliation,Bank Reconciliation,Bank Odsouhlasení
 DocType: Attendance,On Leave,Na odchodu
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Získat aktualizace
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Účet {2} nepatří do společnosti {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +147,Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena
-apps/erpnext/erpnext/config/hr.py +305,Leave Management,Správa absencí
+apps/erpnext/erpnext/stock/doctype/item/item.js +366,Select at least one value from each of the attributes.,Vyberte alespoň jednu hodnotu z každého atributu.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +156,Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena
+apps/erpnext/erpnext/config/hr.py +310,Leave Management,Správa absencí
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Seskupit podle účtu
 DocType: Sales Order,Fully Delivered,Plně Dodáno
 DocType: Lead,Lower Income,S nižšími příjmy
 DocType: Restaurant Order Entry,Current Order,Aktuální objednávka
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +169,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_entry/stock_entry.py +174,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 +241,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Rozdíl účet musí být typu aktiv / Odpovědnost účet, protože to Reklamní Smíření je Entry Otevření"
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Zaplacené částky nemůže být větší než Výše úvěru {0}
-apps/erpnext/erpnext/utilities/user_progress.py +155,Go to Programs,Přejděte na položku Programy
+apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Přejděte na položku Programy
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},"Řádek {0} # Přidělená částka {1} nemůže být vyšší než částka, která nebyla požadována. {2}"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Číslo vydané objednávky je potřebné k položce {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +896,Production Order not created,Výrobní příkaz nebyl vytvořen
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +943,Production Order not created,Výrobní příkaz nebyl vytvořen
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',"""Datum DO"" musí být po ""Datum OD"""
-apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Nemůže změnit statut studenta {0} je propojen s aplikací studentské {1}
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Nemůže změnit statut studenta {0} je propojen s aplikací studentské {1}
 DocType: Asset,Fully Depreciated,plně odepsán
 ,Stock Projected Qty,Reklamní Plánovaná POČET
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,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 +438,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á Účast HTML
 apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Citace jsou návrhy, nabídky jste svým zákazníkům odeslané"
 DocType: Sales Order,Customer's Purchase Order,Zákazníka Objednávka
 DocType: Consultation,Patient,Trpěliví
-apps/erpnext/erpnext/config/stock.py +117,Serial No and Batch,Pořadové číslo a Batch
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Objednávka kreditu bypassu na objednávce
+DocType: Land Unit,Check if it is a hydroponic unit,"Zkontrolujte, zda jde o hydroponickou jednotku"
+apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,Pořadové číslo a Batch
 DocType: Warranty Claim,From Company,Od Společnosti
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Součet skóre hodnotících kritérií musí být {0}.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Prosím nastavte Počet Odpisy rezervováno
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Součet skóre hodnotících kritérií musí být {0}.
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Prosím nastavte Počet Odpisy rezervováno
 DocType: Supplier Scorecard Period,Calculations,Výpočty
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Hodnota nebo Množství
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +425,Productions Orders cannot be raised for:,Productions Objednávky nemůže být zvýšena pro:
-apps/erpnext/erpnext/utilities/user_progress.py +126,Minute,Minuta
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte prosím jmenovací řadu pro {0} přes Nastavení&gt; Nastavení&gt; Pojmenování
+DocType: Payment Terms Template,Payment Terms,Platební podmínky
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +426,Productions Orders cannot be raised for:,Productions Objednávky nemůže být zvýšena pro:
+apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minuta
 DocType: Purchase Invoice,Purchase Taxes and Charges,Nákup Daně a poplatky
-apps/erpnext/erpnext/utilities/user_progress.py +100,Go to Suppliers,Přejděte na dodavatele
+DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
+apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Přejděte na dodavatele
 ,Qty to Receive,Množství pro příjem
 DocType: Leave Block List,Leave Block List Allowed,Nechte Block List povolena
 DocType: Grading Scale Interval,Grading Scale Interval,Klasifikační stupnice Interval
@@ -3336,33 +3559,34 @@
 DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Sleva (%) na cenovou nabídku s marží
 apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Celý sklad
 DocType: Sales Partner,Retailer,Maloobchodník
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +112,Credit To account must be a Balance Sheet account,Připsat na účet musí být účtu Rozvaha
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Připsat na účet musí být účtu Rozvaha
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Všechny typy Dodavatele
+DocType: Donor,Donor,Dárce
 DocType: Global Defaults,Disable In Words,Zakázat ve slovech
-apps/erpnext/erpnext/stock/doctype/item/item.py +51,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},Nabídka {0} není typu {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +49,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 +98,Quotation {0} not of type {1},Nabídka {0} není typu {1}
 DocType: Maintenance Schedule Item,Maintenance Schedule Item,Plán údržby Item
 DocType: Sales Order,%  Delivered,% Dodáno
-apps/erpnext/erpnext/schools/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,"Prosím, nastavte ID e-mailu, aby Student odeslal Žádost o platbu"
+apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,"Prosím, nastavte ID e-mailu, aby Student odeslal Žádost o platbu"
 DocType: Production Order,PRO-,PRO-
 DocType: Patient,Medical History,Zdravotní historie
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Kontokorentní úvěr na účtu
 DocType: Patient,Patient ID,ID pacienta
 DocType: Physician Schedule,Schedule Name,Název plánu
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Vytvořit výplatní pásku
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +813,Add All Suppliers,Přidat všechny dodavatele
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Řádek # {0}: Přidělená částka nesmí být vyšší než zůstatek.
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +838,Add All Suppliers,Přidat všechny dodavatele
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +83,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Řádek # {0}: Přidělená částka nesmí být vyšší než zůstatek.
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Procházet kusovník
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Zajištěné úvěry
 DocType: Purchase Invoice,Edit Posting Date and Time,Úpravy účtování Datum a čas
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosím, amortizace účty s ním souvisejících v kategorii Asset {0} nebo {1} Company"
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosím, amortizace účty s ním souvisejících v kategorii Asset {0} nebo {1} Company"
 DocType: Lab Test Groups,Normal Range,Normální vzdálenost
 DocType: Academic Term,Academic Year,Akademický rok
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Dostupné prodeje
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Počáteční stav Equity
 DocType: Lead,CRM,CRM
 DocType: Purchase Invoice,N,N
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +24,Reconciliation,Smíření
-apps/erpnext/erpnext/schools/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,Zbývající
+apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,Zbývající
 DocType: Appraisal,Appraisal,Ocenění
 DocType: Purchase Invoice,GST Details,Podrobnosti GST
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},E-mailu zaslaného na dodavatele {0}
@@ -3371,22 +3595,23 @@
 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 +215,Leave approver must be one of {0},Schvalovatel absence musí být jedním z {0}
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule.js +66,Create Fees,Vytvořte poplatky
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Vytvořte poplatky
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Celkové pořizovací náklady (přes nákupní faktury)
 DocType: Training Event,Start Time,Start Time
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +377,Select Quantity,Zvolte množství
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +399,Select Quantity,Zvolte množství
 DocType: Customs Tariff Number,Customs Tariff Number,Celního sazebníku
 DocType: Patient Appointment,Patient Appointment,Setkání pacienta
 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 +64,Unsubscribe from this Email Digest,Odhlásit se z tohoto Email Digest
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +803,Get Suppliers By,Získejte dodavatele
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +828,Get Suppliers By,Získejte dodavatele
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{0} nebyl nalezen pro položku {1}
-apps/erpnext/erpnext/utilities/user_progress.py +176,Go to Courses,Přejděte na Kurzy
+apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Přejděte na Kurzy
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Zpráva byla odeslána
-apps/erpnext/erpnext/accounts/doctype/account/account.py +101,Account with child nodes cannot be set as ledger,Účet s podřízené uzly nelze nastavit jako hlavní knihy
+apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Account with child nodes cannot be set as ledger,Účet s podřízené uzly nelze nastavit jako hlavní knihy
 DocType: C-Form,II,II
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou je ceníková měna převedena na základní měnu zákazníka"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá částka (Company Měna)
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +229,Total advance amount cannot be greater than total sanctioned amount,Celková výše zálohy nesmí být vyšší než celková částka sankce
 DocType: Salary Slip,Hour Rate,Hour Rate
 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}
@@ -3402,12 +3627,14 @@
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +155,Source and target warehouse must be different,Zdrojové a cílové sklad se musí lišit
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0}
 DocType: Purchase Invoice Item,PR Detail,PR Detail
+DocType: Driving License Category,Class,Třída
 DocType: Sales Order,Fully Billed,Plně Fakturovaný
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Pravidlo plavby platí pouze pro nákup
 DocType: Vital Signs,BMI,BMI
 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 +136,Delivery warehouse required for stock item {0},Dodávka sklad potřebný pro živočišnou položku {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Dodávka sklad potřebný pro živočišnou 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)
-apps/erpnext/erpnext/schools/doctype/course/course.js +3,Program,Program
+apps/erpnext/erpnext/education/doctype/course/course.js +3,Program,Program
 DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,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šeno
 DocType: Student Group,Group Based On,Skupina založená na
@@ -3415,15 +3642,15 @@
 DocType: Healthcare Settings,Laboratory SMS Alerts,Laboratorní SMS upozornění
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","je nutný servisní položky, typ, frekvence a množství náklady"
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","I když existuje více pravidla pro tvorbu cen s nejvyšší prioritou, pak následující interní priority jsou použity:"
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +128,Do you really want to Submit all Salary Slip from {0} to {1},"Opravdu chcete, aby předložily všechny výplatní pásce z {0} až {1}"
+DocType: Plant Analysis Criteria,Plant Analysis Criteria,Kritéria analýzy rostlin
 DocType: Cheque Print Template,Cheque Height,Šek Výška
 DocType: Supplier,Supplier Details,Dodavatele Podrobnosti
 DocType: Setup Progress,Setup Progress,Pokročilé nastavení
 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 +43,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 +178,Wire Transfer,Bankovní převod
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +132,Check all,Zkontrolovat vše
+apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,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/operations/install_fixtures.py +182,Wire Transfer,Bankovní převod
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Zkontrolovat vše
 DocType: Vehicle Log,Invoice Ref,Faktura Ref
 DocType: Company,Default Income Account,Účet Default příjmů
 apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Zákazník Group / Customer
@@ -3432,19 +3659,18 @@
 DocType: Lab Test Template,Change In Item,Změna položky
 DocType: Payment Gateway Account,Default Payment Request Message,Výchozí 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 +142,Banking and Payments,Bankovnictví a platby
+apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Bankovnictví a platby
 ,Welcome to ERPNext,Vítejte na ERPNext
 apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Lead na nabídku
 DocType: Patient,A Negative,Negativní
 apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Nic víc ukázat.
 DocType: Lead,From Customer,Od Zákazníka
 apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Volá
-apps/erpnext/erpnext/utilities/user_progress.py +122,A Product,Produkt
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +197,Batches,Dávky
-DocType: Project,Total Costing Amount (via Time Logs),Celková kalkulace Částka (přes Time Záznamy)
-apps/erpnext/erpnext/schools/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Udělat rozpis poplatků
+apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Produkt
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,Dávky
+apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Udělat rozpis poplatků
 DocType: Purchase Order Item Supplied,Stock UOM,Reklamní UOM
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +230,Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána
 DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),Normální referenční rozsah pro dospělou osobu je 16-20 dechů / minutu (RCP 2012)
 DocType: Customs Tariff Number,Tariff Number,tarif Počet
 DocType: Production Order Item,Available Qty at WIP Warehouse,Dostupné množství v WIP skladu
@@ -3454,69 +3680,76 @@
 DocType: Notification Control,Quotation Message,Zpráva Nabídky
 DocType: Employee Loan,Employee Loan Application,Zaměstnanec žádost o úvěr
 DocType: Issue,Opening Date,Datum otevření
-apps/erpnext/erpnext/schools/api.py +80,Attendance has been marked successfully.,Účast byla úspěšně označena.
+apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Účast byla úspěšně označena.
 DocType: Program Enrollment,Public Transport,Veřejná doprava
+DocType: Soil Texture,Silt Composition (%),Složené složení (%)
 DocType: Journal Entry,Remark,Poznámka
 DocType: Healthcare Settings,Avoid Confirmation,Vyhněte se potvrzení
 DocType: Purchase Receipt Item,Rate and Amount,Cena a částka
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +165,Account Type for {0} must be {1},Typ účtu pro {0} musí být {1}
 DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,"Výchozí účty příjmů, které se použijí, pokud nejsou zapsány v Lékaři, aby si rezervovali poplatky za konzultace."
 apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Listy a Holiday
-DocType: School Settings,Current Academic Term,Aktuální akademické označení
+DocType: Education Settings,Current Academic Term,Aktuální akademické označení
 DocType: Sales Order,Not Billed,Ne Účtovaný
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,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 +34,No contacts added yet.,Žádné kontakty přidán dosud.
 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/report/accounts_receivable/accounts_receivable.html +78,Debit Note Amt,Debit Note Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Debit Note Amt,Debit Note Amt
 apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Částka slevy
 DocType: Purchase Invoice,Return Against Purchase Invoice,Návrat proti nákupní faktury
 DocType: Item,Warranty Period (in days),Záruční doba (ve dnech)
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Souvislost s Guardian1
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Nepodařilo se nastavit výchozí hodnoty
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Souvislost s Guardian1
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +797,Please select BOM against item {0},Vyberte prosím kusovníku podle položky {0}
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Proveďte faktury
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Čistý peněžní tok z provozní
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Bod 4
 DocType: Student Admission,Admission End Date,Vstupné Datum ukončení
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Subdodávky
 DocType: Journal Entry Account,Journal Entry Account,Zápis do deníku Účet
-apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.js +3,Student Group,Student Group
+apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Student Group
 DocType: Shopping Cart Settings,Quotation Series,Číselná řada nabídek
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +56,"An item exists with same name ({0}), please change the item group name or rename the item","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/accounts/page/pos/pos.js +2005,Please select customer,Vyberte zákazníka
+DocType: Soil Analysis Criteria,Soil Analysis Criteria,Kritéria analýzy půdy
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2020,Please select customer,Vyberte zákazníka
 DocType: C-Form,I,já
 DocType: Company,Asset Depreciation Cost Center,Asset Odpisy nákladového střediska
 DocType: Sales Order Item,Sales Order Date,Prodejní objednávky Datum
 DocType: Sales Invoice Item,Delivered Qty,Dodává Množství
 DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Zda zaškrtnuto, vypíše včetně stromu každé výrobní položky v požadavku materiálu."
 DocType: Assessment Plan,Assessment Plan,Plan Assessment
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90,Customer {0} is created.,Zákazník {0} je vytvořen.
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Zákazník {0} je vytvořen.
 DocType: Stock Settings,Limit Percent,Limit Procento
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,V současné době žádné skladové zásoby nejsou k dispozici
 ,Payment Period Based On Invoice Date,Platební období na základě data vystavení faktury
 DocType: Sample Collection,No. of print,Počet tisku
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Chybí Směnárna Kurzy pro {0}
 DocType: Assessment Plan,Examiner,Zkoušející
-DocType: Patient Relation,Siblings,sourozenci
+DocType: Student,Siblings,sourozenci
 DocType: Journal Entry,Stock Entry,Skladový pohyb
 DocType: Payment Entry,Payment References,Platební Reference
 DocType: C-Form,C-FORM-,C-form-
 DocType: Vehicle,Insurance Details,pojištění Podrobnosti
 DocType: Account,Payable,Splatný
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,"Prosím, zadejte dobu splácení"
-apps/erpnext/erpnext/shopping_cart/cart.py +365,Debtors ({0}),Dlužníci ({0})
+apps/erpnext/erpnext/shopping_cart/cart.py +376,Debtors ({0}),Dlužníci ({0})
 DocType: Pricing Rule,Margin,Marže
 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 +75,Gross Profit %,Hrubý Zisk %
 DocType: Appraisal Goal,Weightage (%),Weightage (%)
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +489,Change POS Profile,Změňte profil POS
 DocType: Bank Reconciliation Detail,Clearance Date,Výprodej Datum
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Zpráva o hodnocení
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Gross Částka nákupu je povinná
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Zpráva o hodnocení
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Gross Částka nákupu je povinná
 DocType: Lead,Address Desc,Popis adresy
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +101,Party is mandatory,Party je povinná
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +102,Party is mandatory,Party je povinná
 DocType: Journal Entry,JV-,JV-
+apps/erpnext/erpnext/controllers/accounts_controller.py +687,Rows with duplicate due dates in other rows were found: {list},V jiných řádcích byly nalezeny řádky s duplicitními daty: {list}
 DocType: Topic,Topic Name,Název tématu
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena
-apps/erpnext/erpnext/public/js/setup_wizard.js +33,Select the nature of your business.,Vyberte podstatu svého podnikání.
+apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Vyberte podstatu svého podnikání.
 DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
 <br>
 Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
@@ -3526,19 +3759,21 @@
 Grouped for test templates which are a group of other test templates.
 <br>
 No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Single pro výsledky, které vyžadují pouze jeden vstup, výsledek UOM a normální hodnota <br> Sloučenina pro výsledky, které vyžadují více vstupních polí s odpovídajícími názvy událostí, výsledky UOM a normální hodnoty <br> Popisné pro testy, které mají více komponent výsledků a odpovídající pole pro vyplnění výsledků. <br> Seskupeny pro testovací šablony, které jsou skupinou dalších zkušebních šablon. <br> Žádný výsledek pro testy bez výsledků. Také není vytvořen žádný laboratorní test. např. Podtřídy pro seskupené výsledky."
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +73,Row #{0}: Duplicate entry in References {1} {2},Řádek # {0}: Duplicitní záznam v odkazu {1} {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +75,Row #{0}: Duplicate entry in References {1} {2},Řádek # {0}: Duplicitní záznam v odkazu {1} {2}
 apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny."
 DocType: Asset Movement,Source Warehouse,Zdroj Warehouse
 DocType: Installation Note,Installation Date,Datum instalace
-apps/erpnext/erpnext/controllers/accounts_controller.py +541,Row #{0}: Asset {1} does not belong to company {2},Řádek # {0}: {1} Asset nepatří do společnosti {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +585,Row #{0}: Asset {1} does not belong to company {2},Řádek # {0}: {1} Asset nepatří do společnosti {2}
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Byla vytvořena prodejní faktura {0}
 DocType: Employee,Confirmation Date,Potvrzení Datum
 DocType: C-Form,Total Invoiced Amount,Celkem Fakturovaná částka
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,Min množství nemůže být větší než Max Množství
+DocType: Soil Texture,Silty Clay,Silty Clay
 DocType: Account,Accumulated Depreciation,oprávky
 DocType: Supplier Scorecard Scoring Standing,Standing Name,Stálé jméno
 DocType: Stock Entry,Customer or Supplier Details,Zákazníka nebo dodavatele Podrobnosti
 DocType: Employee Loan Application,Required by Date,Vyžadováno podle data
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +222,Closing Balance (Dr - Cr),Závěrečný zůstatek (Dr - Cr)
 DocType: Lead,Lead Owner,Majitel leadu
 DocType: Bin,Requested Quantity,Požadované množství
 DocType: Patient,Marital Status,Rodinný stav
@@ -3548,33 +3783,36 @@
 DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Hrubé mzdy - Total dedukce - splátky
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +26,Current BOM and New BOM can not be same,Aktuální BOM a nový BOM nemůže být stejný
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +45,Salary Slip ID,Plat Slip ID
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,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/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +52,There were errors while scheduling course on :,"Došlo k chybám, zatímco rozvrhování kurz na:"
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,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/stock/doctype/item/item.js +68,Multiple Variants,Více variant
 DocType: Sales Invoice,Against Income Account,Proti účet příjmů
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% dodáno
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +95,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množství {1} nemůže být nižší než minimální Objednané množství {2} (definované v bodu).
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +96,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množství {1} nemůže být nižší než minimální Objednané množství {2} (definované v bodu).
 DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Měsíční Distribution Procento
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +90,Please login as another user.,Přihlaste se jako další uživatel.
 DocType: Territory,Territory Targets,Území Cíle
+DocType: Soil Analysis,Ca/Mg,Ca / Mg
 DocType: Delivery Note,Transporter Info,Transporter Info
-apps/erpnext/erpnext/accounts/utils.py +497,Please set default {0} in Company {1},Prosím nastavit výchozí {0} ve firmě {1}
+apps/erpnext/erpnext/accounts/utils.py +499,Please set default {0} in Company {1},Prosím nastavit výchozí {0} ve firmě {1}
 DocType: Cheque Print Template,Starting position from top edge,Výchozí poloha od horního okraje
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +31,Same supplier has been entered multiple times,Stejný dodavatel byl zadán vícekrát
 apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Hrubý zisk / ztráta
 DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Dodané položky vydané objednávky
-apps/erpnext/erpnext/public/js/setup_wizard.js +90,Company Name cannot be Company,Název společnosti nemůže být Company
+apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Název společnosti nemůže být Company
 apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Hlavičkové listy pro tisk š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."
 DocType: Program Enrollment,Walking,Chůze
 DocType: Student Guardian,Student Guardian,Student Guardian
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +201,Valuation type charges can not marked as Inclusive,Poplatky typu ocenění může není označen jako Inclusive
+DocType: Member,Member Name,Jméno člena
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Poplatky typu ocenění může není označen jako Inclusive
 DocType: POS Profile,Update Stock,Aktualizace skladem
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,v předplatném
 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: Membership,Payment Details,Platební ú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 deníku 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 +467,Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený
+apps/erpnext/erpnext/accounts/utils.py +469,Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený
 apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Záznam všech sdělení typu e-mail, telefon, chat, návštěvy, atd"
 DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Hodnocení skóre dodavatele skóre
 DocType: Manufacturer,Manufacturers used in Items,Výrobci používané v bodech
@@ -3584,9 +3822,10 @@
 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
+DocType: Land Unit,Land Unit,Pozemní jednotka
 ,Purchase Analytics,Nákup Analytika
 DocType: Sales Invoice Item,Delivery Note Item,Delivery Note Item
-DocType: Expense Claim,Task,Úkol
+DocType: Asset Maintenance Log,Task,Úkol
 DocType: Purchase Taxes and Charges,Reference Row #,Referenční Row #
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,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.
@@ -3595,8 +3834,8 @@
 apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Rychlost: {0}
 DocType: Company,Exchange Gain / Loss Account,Exchange Zisk / ztráty
 apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Zaměstnanců a docházky
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +78,Purpose must be one of {0},Cíl musí být jedním z {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,Fill the form and save it,Vyplňte formulář a uložte jej
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Purpose must be one of {0},Cíl musí být jedním z {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +116,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 aktuální stav stav zásob, který obsahuje všechny položky"
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum Community
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Aktuální množství na skladě
@@ -3609,7 +3848,7 @@
 DocType: Purchase Order,Get Items from Open Material Requests,Položka získaná z žádostí Otevřít Materiál
 DocType: Lab Test Template,Standard Selling Rate,Standardní prodejní cena
 DocType: Account,Rate at which this tax is applied,"Sazba, při které se používá tato daň"
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +65,Reorder Qty,Změna pořadí Množství
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +75,Reorder Qty,Změna pořadí Množství
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Aktuální pracovní příležitosti
 DocType: Company,Stock Adjustment Account,Reklamní Nastavení účtu
 apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Odepsat
@@ -3620,36 +3859,41 @@
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +49,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Naladil se na aktualizaci nejnovější ceny ve všech kusovnících. Může to trvat několik minut.
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Název nového účtu. Poznámka: Prosím, vytvářet účty pro zákazníky a dodavateli"
 apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Země moudrý výchozí adresa Templates
+DocType: Water Analysis,Appearance,Vzhled
+apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Průměrné Nákupní cena ceníku
 DocType: Sales Order Item,Supplier delivers to Customer,Dodavatel doručí zákazníkovi
+apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Členové informace.
 apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Položka / {0}) není na skladě
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Údržba majetku
 ,Sales Payment Summary,Přehled plateb prodeje
 DocType: Restaurant,Restaurant,Restaurace
-apps/erpnext/erpnext/accounts/party.py +322,Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
+apps/erpnext/erpnext/accounts/party.py +323,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 dat a export
 DocType: Patient,Account Details,Údaje o účtu
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +76,No students Found,Žádní studenti Nalezené
+DocType: Crop,Materials Required,Potřebné materiály
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Žádní studenti Nalezené
 DocType: Medical Department,Medical Department,Lékařské oddělení
 DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Kritéria hodnocení skóre dodavatele skóre
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Faktura Datum zveřejnění
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Prodat
-DocType: Sales Invoice,Rounded Total,Celkem zaokrouhleno
+DocType: Purchase Invoice,Rounded Total,Celkem zaokrouhleno
 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%
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +567,Please select Posting Date before selecting Party,"Prosím, vyberte Datum zveřejnění před výběrem Party"
+DocType: Crop Cycle,Linked Land Unit,Propojená pozemní jednotka
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,"Prosím, vyberte Datum zveřejnění před výběrem Party"
 DocType: Program Enrollment,School House,School House
 DocType: Serial No,Out of AMC,Out of AMC
-apps/erpnext/erpnext/public/js/utils.js +263,Please select Quotations,Vyberte prosím citace
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet Odpisy rezervováno nemůže být větší než celkový počet Odpisy
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet Odpisy rezervováno nemůže být větší než celkový počet Odpisy
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Proveďte návštěv údržby
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +170,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/selling/doctype/customer/customer.py +198,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 +62,Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,To je založeno na účasti tohoto studenta
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Žádné studenty v
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,To je založeno na účasti tohoto studenta
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Žádné studenty v
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +171,Add more items or open full form,Přidat další položky nebo otevřené plné formě
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +206,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/utilities/user_progress.py +238,Go to Users,Přejděte na položku Uživatelé
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +82,Paid amount + Write Off Amount can not be greater than Grand Total,Uhrazená částka + odepsaná částka nesmí být větší než celková částka
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,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/utilities/user_progress.py +256,Go to Users,Přejděte na položku Uživatelé
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Uhrazená částka + odepsaná částka nesmí být větší než celková částka
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} není platná Šarže pro Položku {1}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,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/regional/india/utils.py +15,Invalid GSTIN or Enter NA for Unregistered,Neplatná hodnota GSTIN nebo Zadejte NA pro neregistrované
@@ -3667,31 +3911,35 @@
 DocType: Hub Settings,Publish Availability,Publikování Dostupnost
 DocType: Company,Create Chart Of Accounts Based On,Vytvořte účtový rozvrh založený na
 apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Nelze jej převést na jinou než skupinu. Dětské úkoly existují.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date of Birth cannot be greater than today.,Datum narození nemůže být větší než dnes.
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,Datum narození nemůže být větší než dnes.
 ,Stock Ageing,Reklamní Stárnutí
-apps/erpnext/erpnext/schools/doctype/student/student.py +38,Student {0} exist against student applicant {1},Existují Student {0} proti uchazeč student {1}
+apps/erpnext/erpnext/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Existují Student {0} proti uchazeč student {1}
 DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Úprava zaokrouhlení (měna společnosti)
 apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Rozvrh hodin
-apps/erpnext/erpnext/controllers/accounts_controller.py +233,{0} '{1}' is disabled,{0} '{1}' je vypnuté
+DocType: Volunteer,Afternoon,Odpoledne
+apps/erpnext/erpnext/controllers/accounts_controller.py +256,{0} '{1}' is disabled,{0} '{1}' je vypnuté
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Nastavit jako Otevřít
 DocType: Cheque Print Template,Scanned Cheque,skenovaných Šek
 DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Posílat automatické e-maily na Kontakty na předložení transakcí.
 DocType: Timesheet,Total Billable Amount,Celková částka Zúčtovatelná
+DocType: Customer,Credit Limit and Payment Terms,Úvěrový limit a platební podmínky
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Položka 3
 apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Zadání objednávky
 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: Chapter,Chapter Members,Členové kapitoly
 DocType: Sales Team,Contribution (%),Příspěvek (%)
-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/projects/doctype/project/project.py +65,Project {0} already exists,Projekt {0} již existuje
+apps/erpnext/erpnext/controllers/accounts_controller.py +100,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/projects/doctype/project/project.py +67,Project {0} already exists,Projekt {0} již existuje
 DocType: Medical Department,Nursing User,Ošetřujícího uživatele
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +227,Responsibilities,Odpovědnost
+DocType: Plant Analysis,Plant Analysis Criterias,Kritéria analýzy rostlin
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Responsibilities,Odpovědnost
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Platnost této nabídky skončila.
 DocType: Expense Claim Account,Expense Claim Account,Náklady na pojistná Account
 DocType: Accounts Settings,Allow Stale Exchange Rates,Povolit stávající kurzy měn
 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/utilities/user_progress.py +226,Add Users,Přidat uživatele
+apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Přidat uživatele
 DocType: POS Item Group,Item Group,Skupina položek
 DocType: Item,Safety Stock,Bezpečné skladové množství
 DocType: Healthcare Settings,Healthcare Settings,Nastavení zdravotní péče
@@ -3699,74 +3947,78 @@
 DocType: Stock Reconciliation Item,Before reconciliation,Před smíření
 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 +445,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 +461,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ý
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Item {0} musí být dlouhodobá aktiva položka
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Item {0} musí být dlouhodobá aktiva položka
+apps/erpnext/erpnext/stock/doctype/item/item.js +341,Make Variants,Vytvořte varianty
 DocType: Item,Default BOM,Výchozí BOM
+DocType: Project,Total Billed Amount (via Sales Invoices),Celková fakturační částka (prostřednictvím prodejních faktur)
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Částka pro debetní poznámku
 apps/erpnext/erpnext/setup/doctype/company/company.js +60,Please re-type company name to confirm,Prosím re-typ název společnosti na potvrzení
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +79,Total Outstanding Amt,Celkem Vynikající Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Total Outstanding Amt,Celkem Vynikající Amt
 DocType: Journal Entry,Printing Settings,Tisk Nastavení
+DocType: Employee Advance,Advance Account,Advance účet
 DocType: Sales Invoice,Include Payment (POS),Zahrnují platby (POS)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,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ý
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +290,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/data/industry_type.py +11,Automotive,Automobilový
 DocType: Vehicle,Insurance Company,Pojišťovna
 DocType: Asset Category Account,Fixed Asset Account,Fixed Asset Account
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Variable,Proměnná
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,Proměnná
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Z Dodacího Listu
+DocType: Chapter,Members,Členové
 DocType: Student,Student Email Address,Student E-mailová adresa
 DocType: Item,Hub Warehouse,Hub Warehouse
-DocType: Physician Schedule Time Slot,From Time,Času od
+DocType: Assessment Plan,From Time,Času od
 apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Na skladě:
 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/purchase_invoice/purchase_invoice.py +78,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/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentská adresa
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Investiční bankovnictví
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,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/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentská adresa
 DocType: Purchase Invoice,Price List Exchange Rate,Katalogová cena Exchange Rate
+apps/erpnext/erpnext/accounts/doctype/account/account.py +253,Account Number {0} already used in account {1},Číslo účtu {0} již použito v účtu {1}
 DocType: POS Profile,POS Profile Name,Název profilu POS
 DocType: Purchase Invoice Item,Rate,Cena
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +100,Intern,Internovat
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1569,Address Name,adresa Jméno
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Internovat
+DocType: Delivery Stop,Address Name,adresa Jméno
 DocType: Stock Entry,From BOM,Od BOM
 DocType: Assessment Code,Assessment Code,Kód Assessment
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +69,Basic,Základní
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,Základní
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Fotky transakce před {0} jsou zmrazeny
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',"Prosím, klikněte na ""Generovat Schedule"""
-apps/erpnext/erpnext/config/stock.py +195,"e.g. Kg, Unit, Nos, m","např Kg, ks, č, m"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni"
 DocType: Bank Reconciliation Detail,Payment Document,platba Document
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Chyba při vyhodnocování vzorce kritéria
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +110,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.py +115,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 +827,Issue Material,Vydání Material
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Letecká linka
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +852,Issue Material,Vydání Material
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Při vytváření opakování se vyskytla chyba
 DocType: Material Request Item,For Warehouse,Pro Sklad
 DocType: Employee,Offer Date,Nabídka Date
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Citace
-apps/erpnext/erpnext/accounts/page/pos/pos.js +711,You are in offline mode. You will not be able to reload until you have network.,"Jste v režimu offline. Nebudete moci obnovit stránku, dokud nebudete na síťi."
-apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Žádné studentské skupiny vytvořen.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +726,You are in offline mode. You will not be able to reload until you have network.,"Jste v režimu offline. Nebudete moci obnovit stránku, dokud nebudete na síťi."
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Žádné studentské skupiny vytvořen.
 DocType: Purchase Invoice Item,Serial No,Výrobní číslo
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Měsíční splátka částka nemůže být větší než Výše úvěru
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +55,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Řádek # {0}: Očekávaný datum dodání nemůže být před datem objednávky
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Řádek # {0}: Očekávaný datum dodání nemůže být před datem objednávky
 DocType: Purchase Invoice,Print Language,Tisk Language
 DocType: Salary Slip,Total Working Hours,Celkové pracovní doby
 DocType: Subscription,Next Schedule Date,Další rozvrh datum
 DocType: Stock Entry,Including items for sub assemblies,Včetně položek pro podsestav
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1928,Enter value must be positive,Zadejte hodnota musí být kladná
+DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Účet dočasného zahájení
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1943,Enter value must be positive,Zadejte hodnota musí být kladná
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,Všechny území
 DocType: Purchase Invoice,Items,Položky
-apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +26,Student is already enrolled.,Student je již zapsáno.
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +28,Student is already enrolled.,Student je již zapsáno.
 DocType: Fiscal Year,Year Name,Jméno roku
-DocType: Process Payroll,Process Payroll,Proces Payroll
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,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 +132,Request for Quotations,Žádost o citátů
+apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Žádost o citátů
 DocType: Payment Reconciliation,Maximum Invoice Amount,Maximální částka faktury
-apps/erpnext/erpnext/healthcare/setup.py +209,Haematology,Hematologie
+apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Hematologie
 DocType: Normal Test Items,Normal Test Items,Normální testovací položky
 DocType: Student Language,Student Language,Student Language
 apps/erpnext/erpnext/config/selling.py +23,Customers,zákazníci
@@ -3776,11 +4028,12 @@
 DocType: Asset,Partially Depreciated,částečně odepisována
 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 +675,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Výchozí měrná jednotka varianty &#39;{0}&#39; musí být stejný jako v Template &#39;{1}&#39;
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Cenné papíry a komoditních burzách
+apps/erpnext/erpnext/stock/doctype/item/item.py +661,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Výchozí měrná jednotka varianty &#39;{0}&#39; musí být stejný jako v Template &#39;{1}&#39;
 DocType: Shipping Rule,Calculate Based On,Vypočítat založené na
 DocType: Delivery Note Item,From Warehouse,Ze skladu
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +897,No Items with Bill of Materials to Manufacture,Žádné položky s Billem materiálů k výrobě
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Žádní zaměstnanci nesplnili uvedená kritéria
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +944,No Items with Bill of Materials to Manufacture,Žádné položky s Billem materiálů k výrobě
 DocType: Restaurant,Default Customer,Výchozí zákazník
 DocType: Assessment Plan,Supervisor Name,Jméno Supervisor
 DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,"Nepotvrzujte, zda je událost vytvořena ve stejný den"
@@ -3790,40 +4043,41 @@
 DocType: Tax Rule,Shipping City,Dodací město
 DocType: Notification Control,Customize the Notification,Přizpůsobit oznámení
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Cash flow z provozních činností
-DocType: Sales Invoice,Shipping Rule,Pravidlo dopravy
+DocType: Purchase Invoice,Shipping Rule,Pravidlo dopravy
 DocType: Patient Relation,Spouse,Manželka
 DocType: Lab Test Groups,Add Test,Přidat test
 DocType: Manufacturer,Limited to 12 characters,Omezeno na 12 znaků
 DocType: Journal Entry,Print Heading,Tisk záhlaví
+apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Služba výletů Trip výlety zákazníkům.
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,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 poslední objednávky"" musí být větší nebo rovno nule"
-DocType: Process Payroll,Payroll Frequency,Mzdové frekvence
+DocType: Plant Analysis Criteria,Maximum Permissible Value,Maximální přípustná hodnota
+DocType: Journal Entry Account,Employee Advance,Zaměstnanec Advance
+DocType: Payroll Entry,Payroll Frequency,Mzdové frekvence
 DocType: Lab Test Template,Sensitivity,Citlivost
-DocType: Asset,Amended From,Platném znění
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +58,Raw Material,Surovina
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +62,Raw Material,Surovina
 DocType: Leave Application,Follow via Email,Sledovat e-mailem
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Rostliny a strojní vybavení
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po slevě Částka
 DocType: Daily Work Summary Settings,Daily Work Summary Settings,Každodenní práci Souhrnné Nastavení
 DocType: Payment Entry,Internal Transfer,vnitřní Převod
-apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Child account exists for this account. You can not delete this account.,Dětské konto existuje pro tento účet. Nemůžete smazat tento účet.
+DocType: Asset Maintenance,Maintenance Tasks,Úkoly údržby
 apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Buď cílové množství nebo cílová částka je povinná
-apps/erpnext/erpnext/stock/get_item_details.py +536,No default BOM exists for Item {0},No default BOM existuje pro bod {0}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +359,Please select Posting Date first,"Prosím, vyberte nejprve Datum zveřejnění"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +367,Please select Posting Date first,"Prosím, vyberte nejprve Datum zveřejnění"
 apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Datum zahájení by měla být před uzávěrky
 DocType: Leave Control Panel,Carry Forward,Převádět
 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í."
+DocType: Crop Cycle,Detected Disease,Zjištěná nemoc
 ,Produced,Produkoval
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +118,Created Salary Slips,Vytvořené výplatních páskách
 DocType: Item,Item Code for Suppliers,Položka Kód pro dodavatele
 DocType: Issue,Raised By (Email),Vznesené (e-mail)
 DocType: Training Event,Trainer Name,Jméno trenér
 DocType: Mode of Payment,General,Obecný
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Poslední komunikace
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +355,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/accounts/doctype/purchase_invoice/purchase_invoice.js +372,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/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
-apps/erpnext/erpnext/config/accounts.py +152,Match Payments with Invoices,Zápas platby fakturami
+apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Zápas platby fakturami
 DocType: Journal Entry,Bank Entry,Bank Entry
 DocType: Authorization Rule,Applicable To (Designation),Vztahující se na (označení)
 ,Profitability Analysis,Analýza ziskovost
@@ -3833,17 +4087,19 @@
 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
 DocType: Guardian,Interests,zájmy
-apps/erpnext/erpnext/config/accounts.py +306,Enable / disable currencies.,Povolit / zakázat měny.
+apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Povolit / zakázat měny.
 DocType: Production Planning Tool,Get Material Request,Získat Materiál Request
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,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
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Entertainment & Leisure
+,Item Variant Details,Podrobnosti o variantě položky
 DocType: Quality Inspection,Item Serial No,Položka Výrobní číslo
 apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Vytvořit Zaměstnanecké záznamů
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Celkem Present
-apps/erpnext/erpnext/config/accounts.py +113,Accounting Statements,účetní závěrka
+apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,účetní závěrka
 DocType: Drug Prescription,Hour,Hodina
 DocType: Restaurant Order Entry,Last Sales Invoice,Poslední prodejní faktura
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +799,Please select Qty against item {0},Zvolte prosím množství v položce {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Nové seriové číslo nemůže mít záznam skladu. Sklad musí být nastaven přes skladovou kartu nebo nákupní doklad
 DocType: Lead,Lead Type,Typ leadu
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Nejste oprávněni schvalovat listí na bloku Termíny
@@ -3855,6 +4111,7 @@
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,Neznámý
 DocType: Shipping Rule,Shipping Rule Conditions,Přepravní Článek Podmínky
 DocType: Purchase Invoice,Export Type,Typ exportu
+DocType: Salary Slip Loan,Salary Slip Loan,Úvěrový půjček
 DocType: BOM Update Tool,The new BOM after replacement,Nový BOM po změně
 ,Point of Sale,Místo Prodeje
 DocType: Payment Entry,Received Amount,přijaté Částka
@@ -3862,77 +4119,86 @@
 DocType: GST Settings,GSTIN Email Sent On,GSTIN E-mail odeslán na
 DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop od Guardian
 DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Vytvořit na celé množství, ignoruje již objednané množství"
+DocType: Crop,Planting UOM,Výsadba UOM
 DocType: Account,Tax,Daň
-apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,neoznačený
+apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,neoznačený
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Otevření souhrnu faktur
+DocType: Education Settings,Education Manager,Správce vzdělávání
 DocType: Production Planning Tool,Production Planning Tool,Plánovcí rozvrh
+DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimální délka mezi jednotlivými rostlinami v terénu pro optimální růst
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Doručená položka {0} nemůže být aktualizována s využitím skladového uspokojení, místo toho použijte položku Sklad"
 DocType: Quality Inspection,Report Date,Datum Reportu
 DocType: Student,Middle Name,Prostřední jméno
 DocType: C-Form,Invoices,Faktury
+DocType: Water Analysis,Type of Sample,Typ vzorku
 DocType: Batch,Source Document Name,Název zdrojového dokumentu
 DocType: Job Opening,Job Title,Název pozice
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} znamená, že {1} neposkytne citát, ale byly citovány všechny položky \. Aktualizace stavu nabídky RFQ."
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +971,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximální vzorky - {0} již byly zadány v dávce {1} a položce {2} v dávce {3}.
 DocType: Manufacturing Settings,Update BOM Cost Automatically,Aktualizovat cenu BOM automaticky
 DocType: Lab Test,Test Name,Testovací jméno
 apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Vytvořit uživatele
-apps/erpnext/erpnext/utilities/user_progress.py +126,Gram,Gram
+apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,Gram
 DocType: Supplier Scorecard,Per Month,Za měsíc
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +394,Quantity to Manufacture must be greater than 0.,"Množství, které má výroba musí být větší než 0 ° C."
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,"Množství, které má výroba musí být větší než 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,Obnovovací rychlost a dostupnost
 DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,"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: POS Customer Group,Customer Group,Zákazník Group
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +113,New Batch ID (Optional),Nové číslo dávky (volitelné)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +198,Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +120,New Batch ID (Optional),Nové číslo dávky (volitelné)
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
 DocType: BOM,Website Description,Popis webu
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Čistá změna ve vlastním kapitálu
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +196,Newest,Nejnovější
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Zrušte faktuře {0} první
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Zrušte faktuře {0} první
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-mailová adresa musí být jedinečná, již existuje pro {0}"
 DocType: Serial No,AMC Expiry Date,AMC Datum vypršení platnosti
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +840,Receipt,Příjem
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Receipt,Příjem
 ,Sales Register,Sales Register
 DocType: Daily Work Summary Settings Company,Send Emails At,Posílat e-maily At
 DocType: Quotation,Quotation Lost Reason,Důvod ztráty nabídky
-apps/erpnext/erpnext/public/js/setup_wizard.js +19,Select your Domain,Vyberte si doménu
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +367,Transaction reference no {0} dated {1},Referenční transakce no {0} ze dne {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,Transaction reference no {0} dated {1},Referenční transakce no {0} ze dne {1}
 apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Není nic upravovat.
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +419,Form View,Zobrazení formuláře
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +476,Form View,Zobrazení formuláře
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Shrnutí pro tento měsíc a probíhajícím činnostem
-apps/erpnext/erpnext/utilities/user_progress.py +227,"Add users to your organization, other than yourself.","Přidejte uživatele do vaší organizace, kromě vás."
+apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Přidejte uživatele do vaší organizace, kromě vás."
 DocType: Customer Group,Customer Group Name,Zákazník Group Name
 apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Zatím žádné zákazníky!
 apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Přehled o peněžních tocích
 apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Výše úvěru nesmí být vyšší než Maximální výše úvěru částku {0}
 apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Licence
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +481,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 +485,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
 DocType: Physician,Phone (R),Telefon (R)
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Byly přidány časové úseky
 DocType: Item,Attributes,Atributy
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Povolit šablonu
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +223,Please enter Write Off Account,"Prosím, zadejte odepsat účet"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,"Prosím, zadejte odepsat účet"
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Datum poslední objednávky
 DocType: Patient,B Negative,B Negativní
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Stav údržby musí být zrušen nebo dokončen k odeslání
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Účet {0} nepatří společnosti {1}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +873,Serial Numbers in row {0} does not match with Delivery Note,Sériová čísla v řádku {0} neodpovídají poznámce k doručení
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +878,Serial Numbers in row {0} does not match with Delivery Note,Sériová čísla v řádku {0} neodpovídají poznámce k doručení
 DocType: Student,Guardian Details,Guardian Podrobnosti
 DocType: C-Form,C-Form,C-Form
 apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark docházky pro více zaměstnanců
+DocType: Agriculture Task,Start Day,Den zahájení
 DocType: Vehicle,Chassis No,podvozek Žádné
 DocType: Payment Request,Initiated,Zahájil
 DocType: Production Order,Planned Start Date,Plánované datum zahájení
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +592,Please select a BOM,Vyberte kusovníku
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +596,Please select a BOM,Vyberte kusovníku
 DocType: Serial No,Creation Document Type,Tvorba Typ dokumentu
+DocType: Project Task,View Timesheet,Zobrazit časový rozvrh
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Datum ukončení musí být větší než datum zahájení
 DocType: Leave Type,Is Encash,Je inkasovat
 DocType: Leave Allocation,New Leaves Allocated,Nové Listy Přidělené
 apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Data dle projektu nejsou k dispozici pro nabídku
-apps/erpnext/erpnext/schools/doctype/student_admission/templates/student_admission.html +30,End on,Ukončete
+apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Ukončete
 DocType: Project,Expected End Date,Očekávané datum ukončení
 DocType: Budget Account,Budget Amount,rozpočet Částka
+DocType: Donor,Donor Name,Jméno dárce
 DocType: Appraisal Template,Appraisal Template Title,Posouzení Template Název
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Datum od {0} pro zaměstnance {1} nemůže být před nástupem Datum zaměstnance {2}
 apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Obchodní
@@ -3944,32 +4210,34 @@
 DocType: Expense Claim,More Details,Další podrobnosti
 DocType: Supplier Quotation,Supplier Address,Dodavatel Address
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Rozpočet na účet {1} proti {2} {3} je {4}. To bude přesahovat o {5}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +685,Row {0}# Account must be of type 'Fixed Asset',Řádek {0} # účet musí být typu &quot;Fixed Asset&quot;
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +689,Row {0}# Account must be of type 'Fixed Asset',Řádek {0} # účet musí být typu &quot;Fixed Asset&quot;
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Out Množství
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,a zrušeno Zakázáno v
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,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/setup/setup_wizard/data/industry_type.py +28,Financial Services,Finanční služby
 DocType: Student Sibling,Student ID,Student ID
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +457,Supplier Email,E-mail dodavatele
 apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Typy činností pro Time Záznamy
-DocType: Tax Rule,Sales,Prodej
+DocType: Opening Invoice Creation Tool,Sales,Prodej
 DocType: Stock Entry Detail,Basic Amount,Základní částka
 DocType: Training Event,Exam,Zkouška
 DocType: Complaint,Complaint,Stížnost
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +452,Warehouse required for stock Item {0},Sklad je vyžadován pro skladovou položku {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +456,Warehouse required for stock Item {0},Sklad je vyžadován pro skladovou položku {0}
 DocType: Leave Allocation,Unused leaves,Nepoužité listy
 DocType: Patient,Alcohol Past Use,Alkohol v minulosti
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +179,Cr,Cr
+DocType: Fertilizer Content,Fertilizer Content,Obsah hnojiv
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +188,Cr,Cr
 DocType: Tax Rule,Billing State,Fakturace State
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +276,Transfer,Převod
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +891,Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin)
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +296,Transfer,Převod
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +916,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 +113,Due Date is mandatory,Datum splatnosti je povinné
+apps/erpnext/erpnext/controllers/accounts_controller.py +135,Due Date is mandatory,Datum splatnosti je povinné
 apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Přírůstek pro atribut {0} nemůže být 0
 DocType: Journal Entry,Pay To / Recd From,Platit K / Recd Z
 DocType: Naming Series,Setup Series,Nastavení číselných řad
 DocType: Payment Reconciliation,To Invoice Date,Chcete-li data vystavení faktury
 DocType: Supplier,Contact HTML,Kontakt HTML
+DocType: Disease,Treatment Period,Doba léčby
 ,Inactive Customers,neaktivní zákazníci
 DocType: Student Admission Program,Maximum Age,Maximální věk
 DocType: Landed Cost Voucher,LCV,LCV
@@ -3978,13 +4246,13 @@
 DocType: Stock Entry,Delivery Note No,Dodacího listu
 DocType: Production Planning Tool,"If checked, only Purchase material requests for final raw materials will be included in the Material Requests. Otherwise, Material Requests for parent items will be created","Je-li zaškrtnuto, lze zakoupit pouze materiální Žádost o poskytnutí konečných surovin budou zahrnuty v materiálu požadavky. V opačném případě bude vytvořen Materiál Žádosti o mateřské kusů"
 DocType: Cheque Print Template,Message to show,Zpráva ukázat
-DocType: Company,Retail,Maloobchodní
-DocType: Attendance,Absent,Nepřítomný
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +566,Product Bundle,Bundle Product
+apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Maloobchodní
+DocType: Student Attendance,Absent,Nepřítomný
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Bundle Product
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nelze najít skóre začínající na {0}. Musíte mít stojící skóre pokrývající 0 až 100
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Řádek {0}: Neplatná reference {1}
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +206,No submitted Delivery Notes found,Nebyly nalezeny žádné doručené doručení
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +210,Row {0}: Invalid reference {1},Řádek {0}: Neplatná reference {1}
 DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kupte Daně a poplatky šablony
-DocType: Upload Attendance,Download Template,Stáhnout šablonu
 DocType: Timesheet,TS-,TS-
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: buď debetní nebo kreditní částku je nutné pro {2}
 DocType: GL Entry,Remarks,Poznámky
@@ -3995,29 +4263,33 @@
 apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Udělat Lead
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Tisk a papírnictví
 DocType: Stock Settings,Show Barcode Field,Show čárového kódu Field
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +782,Send Supplier Emails,Poslat Dodavatel e-maily
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +807,Send Supplier Emails,Poslat Dodavatel e-maily
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plat již zpracovány pro období mezi {0} a {1}, ponechte dobu použitelnosti nemůže být mezi tomto časovém období."
-apps/erpnext/erpnext/config/stock.py +132,Installation record for a Serial No.,Instalace rekord pro sériové číslo
 DocType: Guardian Interest,Guardian Interest,Guardian Zájem
-apps/erpnext/erpnext/config/accounts.py +327,Setup default values for POS Invoices,Nastavení výchozích hodnot pro POS faktury
-apps/erpnext/erpnext/config/hr.py +177,Training,Výcvik
+DocType: Volunteer,Availability,Dostupnost
+apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Nastavení výchozích hodnot pro POS faktury
+apps/erpnext/erpnext/config/hr.py +182,Training,Výcvik
 DocType: Timesheet,Employee Detail,Detail zaměstnanec
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,ID e-mailu Guardian1
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,ID e-mailu Guardian1
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,den následujícímu dni a Opakujte na den v měsíci se musí rovnat
 DocType: Lab Prescription,Test Code,Testovací kód
 apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Nastavení titulní stránce webu
+DocType: Delivery Stop,Select/Unselect Delivery Notes,Zvolte / zrušte výběr poznámky k doručení
 DocType: Offer Letter,Awaiting Response,Čeká odpověď
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Výše
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1298,Total Amount {0},Celková částka {0}
-apps/erpnext/erpnext/controllers/item_variant.py +232,Invalid attribute {0} {1},Neplatný atribut {0} {1}
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1375,Total Amount {0},Celková částka {0}
+apps/erpnext/erpnext/controllers/item_variant.py +301,Invalid attribute {0} {1},Neplatný atribut {0} {1}
 DocType: Supplier,Mention if non-standard payable account,Uvedete-li neštandardní splatný účet
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Vyberte jinou skupinu hodnocení než skupinu Všechny skupiny
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Vyberte jinou skupinu hodnocení než skupinu Všechny skupiny
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Řádek {0}: pro položku {1} je požadováno nákladové středisko.
 DocType: Training Event Employee,Optional,Volitelný
 DocType: Salary Slip,Earning & Deduction,Výdělek a dedukce
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,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í.
+DocType: Agriculture Analysis Criteria,Water Analysis,Analýza vody
+DocType: Chapter,Region,Kraj
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,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 +108,Negative Valuation Rate is not allowed,Negativní ocenění není povoleno
 DocType: Holiday List,Weekly Off,Týdenní Off
+apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Znovu načtení propojené analýzy
 DocType: Fiscal Year,"For e.g. 2012, 2012-13","Pro např 2012, 2012-13"
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit)
 DocType: Sales Invoice,Return Against Sales Invoice,Návrat proti prodejní faktuře
@@ -4029,11 +4301,10 @@
 ,Monthly Attendance Sheet,Měsíční Účast Sheet
 DocType: Production Order Item,Production Order Item,Výroba objednávku Položka
 apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Nebyl nalezen žádný záznam
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost of Scrapped Asset,Náklady na sešrotována aktiv
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Náklady na sešrotována aktiv
 apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové středisko je povinný údaj pro položku {2}
 DocType: Vehicle,Policy No,Ne politika
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +659,Get Items from Product Bundle,Položka získaná ze souboru výrobků
-apps/erpnext/erpnext/stock/doctype/item/item.py +663,"As stock exists against an item {0}, you can not enable has variants property","Protože existuje zásoba proti položce {0}, nemůžete povolit vlastnosti variant"
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +684,Get Items from Product Bundle,Položka získaná ze souboru výrobků
 DocType: Asset,Straight Line,Přímka
 DocType: Project User,Project User,projekt Uživatel
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +64,Split,Rozdělit
@@ -4044,6 +4315,8 @@
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Poslední datum komunikace
 DocType: Sales Team,Contact No.,Kontakt Číslo
 DocType: Bank Reconciliation,Payment Entries,Platební Příspěvky
+DocType: Land Unit,Land Unit Details,Podrobnosti pozemku
+DocType: Land Unit,Latitude,Zeměpisná šířka
 DocType: Production Order,Scrap Warehouse,šrot Warehouse
 DocType: Production Order,Check if material transfer entry is not required,"Zkontrolujte, zda není požadováno zadání materiálu"
 DocType: Program Enrollment Tool,Get Students From,Získat studenty z
@@ -4056,77 +4329,83 @@
 DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Prodej Daně a poplatky šablony
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Celkový (Credit)
 DocType: Repayment Schedule,Payment Date,Datum splatnosti
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +107,New Batch Qty,Nové dávkové množství
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +10,Apparel & Accessories,Oblečení a doplňky
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +114,New Batch Qty,Nové dávkové množství
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Oblečení a doplňky
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,"Nelze vyřešit funkci váženého skóre. Zkontrolujte, zda je vzorec platný."
 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í nahoře v produktovém listu."
 DocType: Shipping Rule,Specify conditions to calculate shipping amount,Stanovení podmínek pro vypočítat výši poštovného
+DocType: Program Enrollment,Institute's Bus,Autobus ústavu
 DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit Mražené Příspěvky
 DocType: Supplier Scorecard Scoring Variable,Path,Cesta
 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 +56,Opening Value,otevření Value
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +66,Opening Value,otevření Value
 DocType: Salary Detail,Formula,Vzorec
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
 DocType: Lab Test Template,Lab Test Template,Šablona zkušebního laboratoře
+DocType: Purchase Invoice Item,Total Weight,Celková váha
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Provize z prodeje
 DocType: Offer Letter Term,Value / Description,Hodnota / Popis
-apps/erpnext/erpnext/controllers/accounts_controller.py +565,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Řádek # {0}: Asset {1} nemůže být předložen, je již {2}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +609,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Řádek # {0}: Asset {1} nemůže být předložen, je již {2}"
 DocType: Tax Rule,Billing Country,Fakturace Země
 DocType: Purchase Order Item,Expected Delivery Date,Očekávané datum dodání
 DocType: Restaurant Order Entry,Restaurant Order Entry,Vstup do objednávky restaurace
 apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetní a kreditní nerovná za {0} # {1}. Rozdíl je v tom {2}.
+DocType: Asset Maintenance Task,Assign To Name,Přiřaďte k názvu
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Výdaje na reprezentaci
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +48,Make Material Request,Udělat Materiál Request
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +63,Make Material Request,Udělat Materiál Request
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Otevřít položku {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,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/selling/doctype/sales_order/sales_order.py +222,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
 DocType: Consultation,Age,Věk
 DocType: Sales Invoice Timesheet,Billing Amount,Fakturace Částka
 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.
+DocType: Company,Default Employee Advance Account,Výchozí účet předplatného pro zaměstnance
 apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Žádosti o dovolenou.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán
+apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán
 DocType: Vehicle,Last Carbon Check,Poslední Carbon Check
 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
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +130,Please select quantity on row ,Vyberte množství v řadě
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Vyberte množství v řadě
+apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Udělat počáteční prodejní a nákupní faktury
 DocType: Purchase Invoice,Posting Time,Čas zadání
 DocType: Timesheet,% Amount Billed,% Fakturované částky
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.",&quot;Čas na schůzku&quot; nebyl nastaven pro Dr {0}.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,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 +135,No Item with Serial No {0},No Položka s Serial č {0}
+apps/erpnext/erpnext/stock/get_item_details.py +129,No Item with Serial No {0},No Položka s Serial č {0}
 DocType: Email Digest,Open Notifications,Otevřené Oznámení
 DocType: Payment Entry,Difference Amount (Company Currency),Rozdíl Částka (Company měna)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Přímé náklady
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,"Prosím, nastavte systém pro pojmenování instruktorů ve vzdělání&gt; Nastavení vzdělávání"
 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 +119,Travel Expenses,Cestovní výdaje
 DocType: Maintenance Visit,Breakdown,Rozbor
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Přidání vlastního pole Subscription do doctype {0}
-apps/erpnext/erpnext/controllers/accounts_controller.py +677,Account: {0} with currency: {1} can not be selected,Účet: {0} s měnou: {1} nelze vybrat
+apps/erpnext/erpnext/controllers/accounts_controller.py +789,Account: {0} with currency: {1} can not be selected,Účet: {0} s měnou: {1} nelze vybrat
+DocType: Purchase Receipt Item,Sample Quantity,Množství vzorku
 DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Aktualizujte náklady na BOM automaticky pomocí programu Plánovač, založený na nejnovější hodnotící sazbě / ceníku / posledním nákupu surovin."
 DocType: Bank Reconciliation Detail,Cheque Date,Šek Datum
-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/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}
 DocType: Program Enrollment Tool,Student Applicants,Student Žadatelé
 apps/erpnext/erpnext/setup/doctype/company/company.js +77,Successfully deleted all transactions related to this company!,Úspěšně vypouští všechny transakce související s tímto společnosti!
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Stejně jako u Date
 DocType: Appraisal,HR,HR
 DocType: Program Enrollment,Enrollment Date,zápis Datum
 DocType: Healthcare Settings,Out Patient SMS Alerts,Upozornění na upozornění pacienta
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +96,Probation,Zkouška
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,Zkouška
 apps/erpnext/erpnext/config/hr.py +115,Salary Components,Mzdové Components
 DocType: Program Enrollment Tool,New Academic Year,Nový akademický rok
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +762,Return / Credit Note,Return / dobropis
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +809,Return / Credit Note,Return / dobropis
 DocType: Stock Settings,Auto insert Price List rate if missing,"Auto vložka Ceník sazba, pokud chybí"
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23,Total Paid Amount,Celkem uhrazené částky
 DocType: Production Order Item,Transferred Qty,Přenesená Množství
 apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigace
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +184,Planning,Plánování
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Plánování
 DocType: Material Request,Issued,Vydáno
-apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +14,Student Activity,Studentská aktivita
-DocType: Project,Total Billing Amount (via Time Logs),Celkem Billing Částka (přes Time Záznamy)
+apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Studentská aktivita
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Dodavatel Id
 DocType: Payment Request,Payment Gateway Details,Platební brána Podrobnosti
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +264,Quantity should be greater than 0,Množství by měla být větší než 0
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +267,Quantity should be greater than 0,Množství by měla být větší než 0
 DocType: Journal Entry,Cash Entry,Cash Entry
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Podřízené uzly mohou být vytvořeny pouze na základě typu uzly &quot;skupina&quot;
 DocType: Leave Application,Half Day Date,Half Day Date
@@ -4135,22 +4414,25 @@
 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: Payment Entry,PE-,PE
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +254,Please set default account in Expense Claim Type {0},Prosím nastavit výchozí účet v Expense reklamační typu {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +305,Please set default account in Expense Claim Type {0},Prosím nastavit výchozí účet v Expense reklamační typu {0}
 DocType: Assessment Result,Student Name,Jméno studenta
 DocType: Brand,Item Manager,Manažer Položka
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Mzdové Splatné
 DocType: Buying Settings,Default Supplier Type,Výchozí typ Dodavatel
+DocType: Plant Analysis,Collection Datetime,Čas odběru
 DocType: Production Order,Total Operating Cost,Celkové provozní náklady
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Poznámka: Položka {0} vstoupil vícekrát
 apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Všechny kontakty.
-apps/erpnext/erpnext/public/js/setup_wizard.js +67,Company Abbreviation,Zkratka Company
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Zkratka Company
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Uživatel: {0} neexistuje
+DocType: Payment Term,Day(s) after invoice date,Den (dní) po datu faktury
+DocType: Payment Schedule,Payment Schedule,Platební kalendář
 DocType: Subscription,SUB-,SUB-
 DocType: Item Attribute Value,Abbreviation,Zkratka
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,Platba Entry již existuje
 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.
-apps/erpnext/erpnext/healthcare/setup.py +240,Pathology,Patologie
+apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Patologie
 DocType: Restaurant Order Entry,Restaurant Table,Restaurace Tabulka
 DocType: Leave Type,Max Days Leave Allowed,Max Days Leave povolena
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Sada Daňové Pravidlo pro nákupního košíku
@@ -4163,52 +4445,56 @@
 apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Nabídka pro Lead nebo pro 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 +139,All Customer Groups,Všechny skupiny zákazníků
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Všechny skupiny zákazníků
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,nahromaděné za měsíc
-apps/erpnext/erpnext/controllers/accounts_controller.py +638,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možná není vytvořen záznam směnného kurzu pro {1} na {2}.
+apps/erpnext/erpnext/controllers/accounts_controller.py +750,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možná není vytvořen záznam směnného kurzu pro {1} na {2}.
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +41,Tax Template is mandatory.,Daňová šablona 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
+apps/erpnext/erpnext/accounts/doctype/account/account.py +44,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: Products Settings,Products Settings,Nastavení Produkty
+,Item Price Stock,Položka Cena Sklad
 DocType: Lab Prescription,Test Created,Test byl vytvořen
 DocType: Healthcare Settings,Custom Signature in Print,Vlastní podpis v tisku
 DocType: Account,Temporary,Dočasný
 DocType: Program,Courses,předměty
 DocType: Monthly Distribution Percentage,Percentage Allocation,Procento přidělení
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +124,Secretary,Sekretářka
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Sekretářka
 DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Pokud zakázat, &quot;ve slovech&quot; poli nebude viditelný v jakékoli transakce"
 DocType: Serial No,Distinct unit of an Item,Samostatnou jednotku z položky
 DocType: Supplier Scorecard Criteria,Criteria Name,Název kritéria
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1213,Please set Company,Nastavte společnost
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1289,Please set Company,Nastavte společnost
 DocType: Pricing Rule,Buying,Nákupy
+apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Nemoci a hnojiva
 DocType: HR Settings,Employee Records to be created by,"Zaměstnanec Záznamy, které vytvořil"
 DocType: Patient,AB Negative,AB Negativní
 DocType: Sample Collection,SMPL-,SMPL-
 DocType: POS Profile,Apply Discount On,Použít Sleva na
+DocType: Member,Membership Type,Typ členství
 ,Reqd By Date,Př p Podle data
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Věřitelé
 DocType: Assessment Plan,Assessment Name,Název Assessment
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Řádek # {0}: Výrobní číslo je povinné
 DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Položka Wise Tax Detail
-apps/erpnext/erpnext/public/js/setup_wizard.js +67,Institute Abbreviation,institut Zkratka
+apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,institut Zkratka
 ,Item-wise Price List Rate,Item-moudrý Ceník Rate
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941,Supplier Quotation,Dodavatel Nabídka
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +966,Supplier Quotation,Dodavatel Nabídka
 DocType: Quotation,In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku."
 apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},Množství ({0}) nemůže být zlomek v řádku {1}
 DocType: Consultation,C-,C-
 DocType: Attendance,ATT-,ATT-
-apps/erpnext/erpnext/stock/doctype/item/item.py +457,Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +473,Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
 apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.
 DocType: Item,Opening Stock,Počáteční stav zásob
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Je nutná zákazník
 DocType: Lab Test,Result Date,Datum výsledku
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} je povinné pro návrat
 DocType: Purchase Order,To Receive,Obdržet
-apps/erpnext/erpnext/utilities/user_progress.py +231,user@example.com,user@example.com
+apps/erpnext/erpnext/utilities/user_progress.py +249,user@example.com,user@example.com
+DocType: Asset,Asset Owner,Majitel majetku
 DocType: Employee,Personal Email,Osobní e-mail
 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á
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Makléřská
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Účast na zaměstnance {0} je již označen pro tento den
 DocType: Production Order Operation,"in Minutes
 Updated via 'Time Log'","v minutách 
@@ -4216,15 +4502,15 @@
 DocType: Customer,From Lead,Od Leadu
 apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Objednávky uvolněna pro výrobu.
 apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Vyberte fiskálního roku ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +557,POS Profile required to make POS Entry,"POS Profile požadováno, aby POS Vstup"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +561,POS Profile required to make POS Entry,"POS Profile požadováno, aby POS Vstup"
 DocType: Program Enrollment Tool,Enroll Students,zapsat studenti
 DocType: Lab Test,Approved Date,Datum schválení
 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 +138,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +143,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
 DocType: Serial No,Out of Warranty,Out of záruky
 DocType: BOM Update Tool,Replace,Vyměnit
 apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Nenašli se žádné produkty.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} proti vystavené faktuře {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +358,{0} against Sales Invoice {1},{0} proti vystavené faktuře {1}
 DocType: Antibiotic,Laboratory User,Laboratorní uživatel
 DocType: Sales Invoice,SINV-,SINV-
 DocType: Request for Quotation Item,Project Name,Název projektu
@@ -4234,43 +4520,47 @@
 DocType: Stock Ledger Entry,Stock Value Difference,Reklamní Value Rozdíl
 apps/erpnext/erpnext/config/learn.py +234,Human Resource,Lidské Zdroje
 DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Platba Odsouhlasení Platba
+DocType: Disease,Treatment Task,Úloha léčby
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Daňové Aktiva
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +626,Production Order has been {0},Produkční objednávka byla {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +630,Production Order has been {0},Produkční objednávka byla {0}
 DocType: BOM Item,BOM No,Číslo kusovníku
 DocType: Instructor,INS/,INS /
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,Journal Entry {0} does not have account {1} or already matched against other voucher,Zápis do deníku {0} nemá účet {1} nebo již uzavřeno proti ostatním poukaz
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +158,Journal Entry {0} does not have account {1} or already matched against other voucher,Zápis do deníku {0} nemá účet {1} nebo již uzavřeno proti ostatním poukaz
 DocType: Item,Moving Average,Klouzavý průměr
 DocType: BOM Update Tool,The BOM which will be replaced,"BOM, který bude nahrazen"
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,elektronická zařízení
+DocType: Asset,Maintenance Required,Nutná údržba
 DocType: Account,Debit,Debet
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"Dovolené musí být přiděleny v násobcích 0,5"
 DocType: Production Order,Operation Cost,Provozní náklady
 apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Nahrajte účast ze souboru CSV
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Vynikající Amt
+apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Vynikající Amt
 DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.
 DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Zásoby Starší než [dny]
-apps/erpnext/erpnext/controllers/accounts_controller.py +535,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Řádek # {0}: Prostředek je povinné pro dlouhodobého majetku nákupu / prodeji
+apps/erpnext/erpnext/controllers/accounts_controller.py +579,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Řádek # {0}: Prostředek je povinné pro dlouhodobého majetku nákupu / prodeji
+DocType: Asset Maintenance Team,Maintenance Team Name,Název týmu údržby
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Pokud dva nebo více pravidla pro tvorbu cen se nacházejí na základě výše uvedených podmínek, priorita je aplikována. Priorita je číslo od 0 do 20, zatímco výchozí hodnota je nula (prázdný). Vyšší číslo znamená, že bude mít přednost, pokud existuje více pravidla pro tvorbu cen se za stejných podmínek."
 apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiskální 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 +132,Types of Expense Claim.,Druhy výdajů nároku.
-apps/erpnext/erpnext/controllers/selling_controller.py +176,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Prodejní cena pro položku {0} je nižší než její {1}. Míra prodeje by měla být nejméně {2}
+apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Druhy výdajů nároku.
+apps/erpnext/erpnext/controllers/selling_controller.py +144,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Prodejní cena pro položku {0} je nižší než její {1}. Míra prodeje by měla být nejméně {2}
 DocType: Item,Taxes,Daně
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +324,Paid and Not Delivered,Uhrazené a nedoručené
+DocType: Purchase Invoice Item,Weight Per Unit,Hmotnost na jednotku
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Uhrazené a nedoručené
 DocType: Project,Default Cost Center,Výchozí Center Náklady
 DocType: Bank Guarantee,End Date,Datum ukončení
 apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Sklad Transakce
 DocType: Budget,Budget Accounts,rozpočtové účty
 DocType: Employee,Internal Work History,Vnitřní práce History
 DocType: Depreciation Schedule,Accumulated Depreciation Amount,Oprávky Částka
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Private Equity
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Private Equity
 DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Variabilní ukazatel ukazatele dodavatele
 DocType: Employee Loan,Fully Disbursed,zcela vyčerpán
 DocType: Maintenance Visit,Customer Feedback,Zpětná vazba od zákazníků
 DocType: Account,Expense,Výdaj
-apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Skóre nemůže být větší než maximum bodů
-apps/erpnext/erpnext/utilities/user_progress.py +108,Customers and Suppliers,Zákazníci a dodavatelé
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +36,Score cannot be greater than Maximum Score,Skóre nemůže být větší než maximum bodů
+apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Zákazníci a dodavatelé
 DocType: Item Attribute,From Range,Od Rozsah
 DocType: BOM,Set rate of sub-assembly item based on BOM,Nastavte ocenění položky podsestavy na základě kusovníku
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},syntaktická chyba ve vzorci nebo stavu: {0}
@@ -4279,6 +4569,7 @@
 DocType: Appraisal,APRSL,APRSL
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,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 +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Nechcete-li použít Ceník článek v dané transakce, by měly být všechny platné pravidla pro tvorbu cen zakázáno."
+DocType: Payment Term,Day(s) after the end of the invoice month,Den (den) po skončení měsíce faktury
 DocType: Assessment Group,Parent Assessment Group,Mateřská skupina Assessment
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Jobs
 ,Sales Order Trends,Prodejní objednávky Trendy
@@ -4287,21 +4578,23 @@
 ,Employee Information,Informace o zaměstnanci
 DocType: Stock Entry Detail,Additional Cost,Dodatečné náklady
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"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 +891,Make Supplier Quotation,Vytvořit nabídku dodavatele
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +916,Make Supplier Quotation,Vytvořit nabídku dodavatele
 DocType: Quality Inspection,Incoming,Přicházející
-apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Výsledky hodnocení {0} již existuje.
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Výsledky hodnocení {0} již existuje.
 DocType: BOM,Materials Required (Exploded),Potřebný materiál (Rozložený)
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',"Nastavte filtr společnosti prázdný, pokud je Skupina By je &#39;Company&#39;"
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Vysílání datum nemůže být budoucí datum
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Řádek # {0}: Výrobní číslo {1} neodpovídá {2} {3}
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,pro generování opakování
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +82,Casual Leave,Casual Leave
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Casual Leave
 apps/erpnext/erpnext/config/healthcare.py +138,Lab Test UOM.,Laboratorní test UOM.
+DocType: Agriculture Task,End Day,Den konce
 DocType: Batch,Batch ID,Šarže ID
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Poznámka: {0}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Poznámka: {0}
 ,Delivery Note Trends,Dodací list Trendy
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Tento týden Shrnutí
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +20,In Stock Qty,Na skladě Množství
+DocType: Delivery Trip,Calculate Estimated Arrival Times,Vypočítat odhadované časy příjezdu
 apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím Skladových Transakcí
 DocType: Student Group Creation Tool,Get Courses,Získat kurzy
 DocType: GL Entry,Party,Strana
@@ -4310,59 +4603,68 @@
 DocType: Sales Order,Delivery Date,Dodávka Datum
 DocType: Opportunity,Opportunity Date,Příležitost Datum
 DocType: Purchase Receipt,Return Against Purchase Receipt,Návrat Proti doklad o koupi
+DocType: Water Analysis,Person Responsible,Zodpovědná osoba
 DocType: Request for Quotation Item,Request for Quotation Item,Žádost o cenovou nabídku výtisku
 DocType: Purchase Order,To Bill,Billa
 DocType: Material Request,% Ordered,% objednáno
-DocType: School Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Pro kurzovou studentskou skupinu bude kurz pro každého studenta ověřen z přihlášených kurzů při zápisu do programu.
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +99,Piecework,Úkolová práce
+DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Pro kurzovou studentskou skupinu bude kurz pro každého studenta ověřen z přihlášených kurzů při zápisu do programu.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Úkolová práce
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Buying Rate,Avg. Nákup Rate
 DocType: Task,Actual Time (in Hours),Skutečná doba (v hodinách)
 DocType: Employee,History In Company,Historie ve Společnosti
 apps/erpnext/erpnext/config/learn.py +107,Newsletters,Zpravodaje
 DocType: Drug Prescription,Description/Strength,Popis / Pevnost
 DocType: Stock Ledger Entry,Stock Ledger Entry,Reklamní Ledger Entry
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +82,Same item has been entered multiple times,Stejný bod byl zadán vícekrát
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Stejný bod byl zadán vícekrát
 DocType: Department,Leave Block List,Nechte Block List
-DocType: Sales Invoice,Tax ID,DIČ
+DocType: Purchase Invoice,Tax ID,DIČ
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,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,Nastavení účtu
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +38,Approve,Schvalovat
-apps/erpnext/erpnext/schools/doctype/assessment_result_tool/assessment_result_tool.js +149,No Result to submit,Žádný výsledek k odeslání
+apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,Schvalovat
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +51,"Malformatted address for {0}, please fix to continue.","Malformátovaná adresa pro {0}, opravte prosím a pokračujte."
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix",Číslo nového účtu bude do názvu účtu zahrnuto jako předčíslí
+DocType: Maintenance Team Member,Team Member,Člen týmu
+apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Žádný výsledek k odeslání
 DocType: Customer,Sales Partner and Commission,Prodej Partner a Komise
 DocType: Employee Loan,Rate of Interest (%) / Year,Úroková sazba (%) / rok
 ,Project Quantity,projekt Množství
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Celkem {0} pro všechny položky je nula, může být byste měli změnit &quot;Rozdělte poplatků založený na&quot;"
 DocType: Opportunity,To Discuss,K projednání
-apps/erpnext/erpnext/stock/stock_ledger.py +368,{0} units of {1} needed in {2} to complete this transaction.,{0} jednotek {1} zapotřebí {2} pro dokončení této transakce.
+apps/erpnext/erpnext/stock/stock_ledger.py +375,{0} units of {1} needed in {2} to complete this transaction.,{0} jednotek {1} zapotřebí {2} pro dokončení této transakce.
 DocType: Loan Type,Rate of Interest (%) Yearly,Úroková sazba (%) Roční
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Dočasné Účty
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +203,Black,Černá
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Černá
 DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Item
 DocType: Account,Auditor,Auditor
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} předměty vyrobené
 apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Další informace
 DocType: Cheque Print Template,Distance from top edge,Vzdálenost od horního okraje
-apps/erpnext/erpnext/stock/get_item_details.py +317,Price List {0} is disabled or does not exist,Ceníková cena {0} je zakázáno nebo neexistuje
+apps/erpnext/erpnext/stock/get_item_details.py +360,Price List {0} is disabled or does not exist,Ceníková cena {0} je zakázáno nebo neexistuje
 DocType: Purchase Invoice,Return,Zpáteční
 DocType: Production Order Operation,Production Order Operation,Výrobní zakázka Operace
 DocType: Pricing Rule,Disable,Zakázat
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +161,Mode of payment is required to make a payment,Způsob platby je povinen provést platbu
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Mode of payment is required to make a payment,Způsob platby je povinen provést platbu
 DocType: Project Task,Pending Review,Čeká Review
+apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Upravte celou stránku pro další možnosti, jako jsou majetek, sériový nos, šarže atd."
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Setkání a konzultace
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} není zapsána v dávce {2}
-apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Aktiva {0} nemůže být vyhozen, jak je tomu již {1}"
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} není zapsána v dávce {2}
+apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Aktiva {0} nemůže být vyhozen, jak je tomu již {1}"
 DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku)
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Absent
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Nepodařilo se nastavit firmu
+DocType: Asset Repair,Asset Repair,Opravy aktiv
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +140,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Řádek {0}: Měna BOM # {1} by se měla rovnat vybrané měně {2}
 DocType: Journal Entry Account,Exchange Rate,Exchange Rate
 DocType: Patient,Additional information regarding the patient,Další informace týkající se pacienta
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +575,Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +579,Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena
 DocType: Homepage,Tag Line,tag linka
 DocType: Fee Component,Fee Component,poplatek Component
-apps/erpnext/erpnext/config/hr.py +199,Fleet Management,Fleet management
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +939,Add items from,Přidat položky z
+apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Fleet management
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +964,Add items from,Přidat položky z
+apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Plodiny a půdy
 DocType: Cheque Print Template,Regular,Pravidelný
-apps/erpnext/erpnext/schools/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Celková weightage všech hodnotících kritérií musí být 100%
+DocType: Fertilizer,Density (if liquid),Hustota (pokud je kapalina)
+apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Celková weightage všech hodnotících kritérií musí být 100%
 DocType: Purchase Order Item,Last Purchase Rate,Poslední nákupní sazba
 DocType: Account,Asset,Majetek
 DocType: Project Task,Task ID,Task ID
@@ -4372,29 +4674,33 @@
 DocType: Training Event,Contact Number,Kontaktní číslo
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Sklad {0} neexistuje
 DocType: Monthly Distribution,Monthly Distribution Percentages,Měsíční Distribuční Procenta
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +37,The selected item cannot have Batch,Vybraná položka nemůže mít dávku
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +38,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álů doručeno proti tomuto dodacímu listu
-DocType: Training Event,Has Certificate,Má certifikát
+DocType: Asset Maintenance Log,Has Certificate,Má certifikát
 DocType: Project,Customer Details,Podrobnosti zákazníků
+DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,"Zkontrolujte, zda majetek vyžaduje preventivní údržbu nebo kalibraci"
 DocType: Employee,Reports to,Zprávy
 ,Unpaid Expense Claim,Neplacené Náklady na pojistná
 DocType: Payment Entry,Paid Amount,Uhrazené částky
-apps/erpnext/erpnext/utilities/user_progress.py +137,Explore Sales Cycle,Prozkoumejte prodejní cyklus
+apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Prozkoumejte prodejní cyklus
 DocType: Assessment Plan,Supervisor,Dozorce
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +73,Online,Online
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +70,Online,Online
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +867,Retention Stock Entry,Retention Stock Entry
 ,Available Stock for Packing Items,K dispozici skladem pro balení položek
 DocType: Item Variant,Item Variant,Položka Variant
 DocType: Assessment Result Tool,Assessment Result Tool,Assessment Tool Výsledek
 DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
-apps/erpnext/erpnext/accounts/page/pos/pos.js +871,Submitted orders can not be deleted,Předložené objednávky nelze smazat
-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 +114,Quality Management,Řízení kvality
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +41,Item {0} has been disabled,Item {0} byl zakázán
+apps/erpnext/erpnext/accounts/page/pos/pos.js +886,Submitted orders can not be deleted,Předložené objednávky nelze smazat
+apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Řízení kvality
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Item {0} byl zakázán
+DocType: Project,Total Billable Amount (via Timesheets),Celková fakturační částka (prostřednictvím časových lístků)
+DocType: Agriculture Task,Previous Business Day,Předchozí pracovní den
 DocType: Employee Loan,Repay Fixed Amount per Period,Splatit pevná částka na období
 apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},"Zadejte prosím množství produktů, bod {0}"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Credit Note Amt,Úvěrová poznámka Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Credit Note Amt,Úvěrová poznámka Amt
 DocType: Employee External Work History,Employee External Work History,Zaměstnanec vnější práce History
-DocType: Tax Rule,Purchase,Nákup
+DocType: Opening Invoice Creation Tool,Purchase,Nákup
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Zůstatek Množství
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Cíle nemůže být prázdný
 DocType: Item Group,Parent Item Group,Parent Item Group
@@ -4402,23 +4708,25 @@
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} pro {1}
 DocType: Healthcare Settings,Valid number of days,Platný počet dnů
 apps/erpnext/erpnext/setup/doctype/company/company.js +35,Cost Centers,Nákladové středisko
+DocType: Land Unit,Linked Plant Analysis,Analýza propojených rostlin
 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: Purchase Invoice Item,Allow Zero Valuation Rate,Povolit nulovou míru oceňování
 DocType: Training Event Employee,Invited,Pozván
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Více aktivní Plat Structures nalezených pro zaměstnance {0} pro dané termíny
-apps/erpnext/erpnext/config/accounts.py +316,Setup Gateway accounts.,Nastavení brány účty.
+apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Nastavení 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 +42,Fixed Assets,Dlouhodobý majetek
 DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange zisk / ztráta
 ,GST Purchase Register,GST Nákupní registr
 ,Cash Flow,Tok peněz
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Období pro podávání žádostí nemůže být na dvou alokace záznamy
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Kombinovaná část faktury se musí rovnat 100%
 DocType: Item Group,Default Expense Account,Výchozí výdajový účet
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student ID e-mailu
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Student ID e-mailu
 DocType: Employee,Notice (days),Oznámení (dny)
 DocType: Tax Rule,Sales Tax Template,Daň z prodeje Template
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2448,Select items to save the invoice,"Vyberte položky, které chcete uložit fakturu"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2467,Select items to save the invoice,"Vyberte položky, které chcete uložit fakturu"
 DocType: Employee,Encashment Date,Inkaso Datum
 DocType: Training Event,Internet,Internet
 DocType: Special Test Template,Special Test Template,Speciální zkušební šablona
@@ -4428,6 +4736,7 @@
 DocType: Academic Term,Term Start Date,Termín Datum zahájení
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +242,Please find attached {0} #{1},V příloze naleznete {0} # {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +701,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Celková částka platby v rozpisu plateb se musí rovnat hodnotě Grand / Rounded Total
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Výpis z bankovního účtu zůstatek podle hlavní knihy
 DocType: Job Applicant,Applicant Name,Žadatel Název
 DocType: Authorization Rule,Customer / Item Name,Zákazník / Název zboží
@@ -4441,6 +4750,7 @@
 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,Atribut
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Uveďte prosím z / do rozmezí
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Otevření {0} Fakturu vytvořena
 DocType: Serial No,Under AMC,Podle AMC
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,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 +153,Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.
@@ -4452,53 +4762,57 @@
 apps/erpnext/erpnext/config/support.py +22,Warranty,Záruka
 DocType: Purchase Invoice,Debit Note Issued,Vydání dluhopisu
 DocType: Production Order,Warehouses,Sklady
-apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} pohledávka nemůže být převedena
-apps/erpnext/erpnext/stock/doctype/item/item.js +66,This Item is a Variant of {0} (Template).,Tato položka je variantou {0} (šablony).
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} aktivum nemůže být převedeno
+apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Tato položka je variantou {0} (šablony).
 DocType: Workstation,per hour,za hodinu
 apps/erpnext/erpnext/config/buying.py +7,Purchasing,Nákup
 DocType: Announcement,Announcement,Oznámení
-DocType: School Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Pro dávkovou studentskou skupinu bude studentská dávka ověřena pro každého studenta ze zápisu do programu.
+DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",Pro dávkovou studentskou skupinu bude studentská dávka ověřena pro každého studenta ze zápisu do programu.
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,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/setup_wizard.js +25,Distribution,Distribuce
+DocType: Expense Claim Advance,Expense Claim Advance,Nároky na úhradu nákladů
 DocType: Lab Test,Report Preference,Předvolba reportu
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +129,Project Manager,Project Manager
+apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Informace o dobrovolnictví.
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Project Manager
 ,Quoted Item Comparison,Citoval Položka Porovnání
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Překrývající bodování mezi {0} a {1}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +110,Dispatch,Odeslání
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Odeslání
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Net Asset value as on,Čistá hodnota aktiv i na
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Čistá hodnota aktiv i na
+DocType: Crop,Produce,Vyrobit
 DocType: Account,Receivable,Pohledávky
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +288,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Řádek # {0}: Není povoleno měnit dodavatele, objednávky již existuje"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Řádek # {0}: Není povoleno měnit dodavatele, objednávky již 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."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +929,Select Items to Manufacture,Vyberte položky do Výroba
-apps/erpnext/erpnext/accounts/page/pos/pos.js +939,"Master data syncing, it might take some time","Kmenová data synchronizace, může to trvat nějaký čas"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +978,Select Items to Manufacture,Vyberte položky do Výroba
+DocType: Delivery Stop,Delivery Stop,Zastávka doručení
+apps/erpnext/erpnext/accounts/page/pos/pos.js +954,"Master data syncing, it might take some time","Kmenová data synchronizace, může to trvat nějaký čas"
 DocType: Item,Material Issue,Material Issue
 DocType: Employee Education,Qualification,Kvalifikace
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +40,View Salary Slips,Zobrazit výplatní pásky
 DocType: Item Price,Item Price,Položka Cena
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +48,Soap & Detergent,Soap & Detergent
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Soap & Detergent
 DocType: BOM,Show Items,Zobrazit položky
-apps/erpnext/erpnext/schools/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Od doby nemůže být větší než na čas.
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +36,Motion Picture & Video,Motion Picture & Video
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Od doby nemůže být větší než na čas.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +74,Do you want to notify all the customers by email?,Chcete upozornit všechny zákazníky e-mailem?
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Motion Picture & Video
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Objednáno
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,Životopis
-DocType: Item Variant Settings,If enabled then system will not update the fields of variants from the template but will copy the data of below mentioned fields while making new variant,"Pokud je tato možnost povolena, systém nebude aktualizovat pole variant z šablony, ale zkopíruje data níže uvedených polí při vytváření nové varianty"
 DocType: Salary Detail,Component,Komponent
 DocType: Assessment Criteria,Assessment Criteria Group,Hodnotící kritéria Group
 DocType: Healthcare Settings,Patient Name By,Jméno pacienta
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Otevření Oprávky musí být menší než rovná {0}
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Otevření Oprávky musí být menší než rovná {0}
 DocType: Warehouse,Warehouse Name,Název Skladu
 DocType: Naming Series,Select Transaction,Vybrat Transaction
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel
 DocType: Journal Entry,Write Off Entry,Odepsat Vstup
 DocType: BOM,Rate Of Materials Based On,Ocenění materiálů na bázi
-DocType: Item Variant Settings,Do not Update Variants,Neaktualizujte varianty
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Podpora Analtyics
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +142,Uncheck all,Zrušte všechny
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Zrušte všechny
 DocType: POS Profile,Terms and Conditions,Podmínky
 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 můžete upravovat svou výšku, váhu, alergie, zdravotní problémy atd"
 DocType: Leave Block List,Applies to Company,Platí pro firmy
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +202,Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože existuje skladový záznam {0}"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +222,Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože existuje skladový záznam {0}"
 DocType: Employee Loan,Disbursement Date,výplata Datum
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&quot;Příjemci&quot; nejsou specifikováni
 DocType: BOM Update Tool,Update latest price in all BOMs,Aktualizujte nejnovější cenu všech kusovníků
@@ -4507,43 +4821,52 @@
 DocType: Purchase Invoice,In Words,Slovy
 apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} musí být odesláno
 DocType: POS Profile,Item Groups,Položka Skupiny
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +217,Today is {0}'s birthday!,Dnes je {0} 's narozeniny!
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Dnes je {0} 's narozeniny!
 DocType: Production Planning Tool,Material Request For Warehouse,Požadavek materiálu na sklad
 DocType: Sales Order Item,For Production,Pro Výrobu
 DocType: Payment Request,payment_url,payment_url
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +163,Please add a Temporary Opening account in Chart of Accounts,Přidejte účet dočasného otevírání do Účtovacího plánu
+DocType: Customer,Customer Primary Contact,Primární kontakt zákazníka
 DocType: Project Task,View Task,Zobrazit Task
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Olovo%
 DocType: Material Request,MREQ-,MREQ-
+DocType: Payment Schedule,Invoice Portion,Fakturační část
 ,Asset Depreciations and Balances,Asset Odpisy a zůstatků
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +356,Amount {0} {1} transferred from {2} to {3},Množství {0} {1} převedena z {2} na {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} transferred from {2} to {3},Množství {0} {1} převedena z {2} na {3}
 DocType: Sales Invoice,Get Advances Received,Získat přijaté zálohy
 DocType: Email Digest,Add/Remove Recipients,Přidat / Odebrat příjemce
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +461,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 +486,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 +205,Join,Připojit
+apps/erpnext/erpnext/projects/doctype/project/project.py +216,Join,Připojit
 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 +699,Item variant {0} exists with same attributes,Bod varianta {0} existuje s stejné atributy
+apps/erpnext/erpnext/stock/doctype/item/item.py +645,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,"Vlastnosti Variantu nelze změnit po přemístění zásob. Budete muset vytvořit novou položku, abyste to udělali."
+apps/erpnext/erpnext/stock/doctype/item/item.py +685,Item variant {0} exists with same attributes,Bod varianta {0} existuje s stejné atributy
 DocType: Employee Loan,Repay from Salary,Splatit z platu
 DocType: Leave Application,LAP/,ÚSEK/
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},Požadovala vyplacení proti {0} {1} na částku {2}
 DocType: Salary Slip,Salary Slip,Výplatní páska
 DocType: Lead,Lost Quotation,ztratil Citace
-apps/erpnext/erpnext/utilities/user_progress.py +200,Student Batches,Studentské dávky
+apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Studentské dávky
 DocType: Pricing Rule,Margin Rate or Amount,Margin sazbou nebo pevnou částkou
 apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,"""Datum 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: Stock Settings,Convert Item Description to Clean HTML,Převést položku Popis k vyčištění HTML
 DocType: Patient,Dormant,Spící
+DocType: Salary Slip,Total Interest Amount,Celková částka úroků
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Sklady s podřízené uzly nelze převést do hlavní účetní knihy
 DocType: BOM,Manage cost of operations,Správa nákladů na provoz
 DocType: Accounts Settings,Stale Days,Stale Days
 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ální nastavení
+DocType: Crop,Row Spacing UOM,Rozložení řádků UOM
 DocType: Assessment Result Detail,Assessment Result Detail,Posuzování Detail Výsledek
 DocType: Employee Education,Employee Education,Vzdělávání zaměstnanců
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +48,Duplicate item group found in the item group table,Duplicitní skupinu položek uvedeny v tabulce na položku ve skupině
-apps/erpnext/erpnext/public/js/controllers/transaction.js +965,It is needed to fetch Item Details.,"Je třeba, aby přinesla Detaily položky."
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Duplicitní skupinu položek uvedeny v tabulce na položku ve skupině
+DocType: Land Unit,Parent Land Unit,Rodičovská jednotka
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1045,It is needed to fetch Item Details.,"Je třeba, aby přinesla Detaily položky."
+DocType: Fertilizer,Fertilizer Name,Jméno hnojiva
 DocType: Salary Slip,Net Pay,Net Pay
 DocType: Account,Account,Účet
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Pořadové číslo {0} již obdržel
@@ -4551,40 +4874,45 @@
 DocType: Expense Claim,Vehicle Log,jízd
 DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Přítomnost horečky (teplota&gt; 38,5 ° C nebo trvalá teplota&gt; 38 ° C / 100,4 ° F)"
 DocType: Customer,Sales Team Details,Podrobnosti prodejní tým
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1326,Delete permanently?,Smazat trvale?
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1341,Delete permanently?,Smazat trvale?
 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.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Neplatný {0}
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Sick Leave,Zdravotní dovolená
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Zdravotní dovolená
 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/setup/setup_wizard/data/industry_type.py +22,Department Stores,Obchodní domy
 ,Item Delivery Date,Datum dodání položky
 DocType: Warehouse,PIN,KOLÍK
-apps/erpnext/erpnext/setup/setup_wizard/sample_data.py +110,Setup your School in ERPNext,Nastavte si škola v ERPNext
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +125,Error '{0}' occured. Arguments {1}.,Došlo k chybě {0}. Argumenty {1}.
 DocType: Sales Invoice,Base Change Amount (Company Currency),Základna Změna Částka (Company měna)
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady
 apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Uložte dokument jako první.
+apps/erpnext/erpnext/shopping_cart/cart.py +71,Only {0} in stock for item {1},Pouze {0} skladem pro položku {1}
 DocType: Account,Chargeable,Vyměřovací
 DocType: Company,Change Abbreviation,Změna zkratky
 DocType: Expense Claim Detail,Expense Date,Datum výdaje
 DocType: Item,Max Discount (%),Max sleva (%)
+apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Dny úvěrů nemohou být záporné číslo
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Částka poslední objednávky
+apps/erpnext/erpnext/stock/doctype/item/item.py +264," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Zachovat vzorek je založen na dávce, zkontrolujte prosím, zda je číslo dávky zadrženo vzorku položky"
 DocType: Task,Is Milestone,Je milník
-DocType: Daily Work Summary,Email Sent To,E-mailem odeslaným
+DocType: Delivery Stop,Email Sent To,E-mailem odeslaným
 DocType: Budget,Warn,Varovat
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Opravdu chcete zrušit registraci?
 DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Jakékoli jiné poznámky, pozoruhodné úsilí, které by měly jít v záznamech."
-DocType: BOM,Manufacturing User,Výroba Uživatel
+DocType: Asset Maintenance,Manufacturing User,Výroba Uživatel
 DocType: Purchase Invoice,Raw Materials Supplied,Dodává suroviny
 DocType: C-Form,Series,Série
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +270,Currency of the price list {0} must be {1} or {2},Měna ceníku {0} musí být {1} nebo {2}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +273,Currency of the price list {0} must be {1} or {2},Měna ceníku {0} musí být {1} nebo {2}
 DocType: Appraisal,Appraisal Template,Posouzení Template
+DocType: Soil Texture,Ternary Plot,Ternary Plot
 DocType: Item Group,Item Classification,Položka Klasifikace
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +127,Business Development Manager,Business Development Manager
+DocType: Driver,License Number,Číslo licence
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Business Development Manager
 DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Maintenance Visit Účel
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Fakturační registrace pacienta
-DocType: Drug Prescription,Period,Období
+DocType: Crop,Period,Období
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Hlavní Účetní Kniha
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Zaměstnanec {0} jsou na dovolené z {1}
 apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Zobrazit Vodítka
@@ -4592,9 +4920,9 @@
 DocType: Item Attribute Value,Attribute Value,Hodnota atributu
 ,Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level
 DocType: Salary Detail,Salary Detail,plat Detail
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1017,Please select {0} first,"Prosím, nejprve vyberte {0}"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,"Prosím, nejprve vyberte {0}"
 DocType: Appointment Type,Physician,Lékař
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +804,Batch {0} of Item {1} has expired.,Šarže {0} položky {1} vypršela.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +833,Batch {0} of Item {1} has expired.,Šarže {0} položky {1} vypršela.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Konzultace
 DocType: Sales Invoice,Commission,Provize
 apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Čas list pro výrobu.
@@ -4605,7 +4933,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Sklad nebyl nalezen v systému
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Tento měsíc je shrnutí
 DocType: Quality Inspection Reading,Quality Inspection Reading,Kvalita Kontrola Reading
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +24,`Freeze Stocks Older Than` should be smaller than %d days.,`Zmrazit zásoby starší než` by mělo být nižší než %d dnů.
+apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,`Zmrazit zásoby starší než` by mělo být nižší než %d dnů.
 DocType: Tax Rule,Purchase Tax Template,Spotřební daň šablony
 apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,"Nastavte cíl prodeje, který byste chtěli dosáhnout pro vaši společnost."
 ,Project wise Stock Tracking,Sledování zboží dle projektu
@@ -4613,42 +4941,50 @@
 apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratoř
 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/accounts/doctype/pos_profile/pos_profile.py +66,Customer Group is Required in POS Profile,Zákaznická skupina je vyžadována v POS profilu
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +71,Customer Group is Required in POS Profile,Zákaznická skupina je vyžadována v POS profilu
 apps/erpnext/erpnext/config/hr.py +12,Employee records.,Zaměstnanecké záznamy.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +92,Please set Next Depreciation Date,"Prosím, stojí vedle odpisů Datum"
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +92,Please set Next Depreciation Date,"Prosím, stojí vedle odpisů Datum"
 DocType: HR Settings,Payroll Settings,Nastavení Mzdové
-apps/erpnext/erpnext/config/accounts.py +154,Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
+apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
 DocType: POS Settings,POS Settings,Nastavení POS
 apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Objednat
 DocType: Email Digest,New Purchase Orders,Nové vydané objednávky
 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 +57,Select Brand...,Select Brand ...
+apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Neziskové (beta)
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Události / výsledky školení
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Accumulated Depreciation as on,Oprávky i na
+apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Oprávky i na
 DocType: Sales Invoice,C-Form Applicable,C-Form Použitelné
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +399,Operation Time must be greater than 0 for Operation {0},Čas operace musí být větší než 0 pro operaci {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +419,Operation Time must be greater than 0 for Operation {0},Čas operace musí být větší než 0 pro operaci {0}
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Sklad je povinné
 DocType: Supplier,Address and Contacts,Adresa a kontakty
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Nepodařilo se vytvořit webové stránky
+DocType: Soil Analysis,Mg/K,Mg / K
 DocType: UOM Conversion Detail,UOM Conversion Detail,UOM konverze Detail
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +922,Retention Stock Entry already created or Sample Quantity not provided,Záznam již vytvořeného záznamu o skladování nebo neposkytnuté množství vzorku
 DocType: Program,Program Abbreviation,Program Zkratka
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Production Order cannot be raised against a Item Template,Výrobní zakázka nemůže být vznesena proti šablony položky
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,Production Order cannot be raised against a Item Template,Výrobní zakázka nemůže být vznesena proti šablony položky
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,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: Bank Guarantee,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 +42,Cheques and Deposits incorrectly cleared,Šeky a Vklady nesprávně vymazány
-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
+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
 DocType: Purchase Invoice Item,Price List Rate,Ceník Rate
 apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Vytvořit citace zákazníků
 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,Průměrná doba pořízena dodavatelem dodat
 DocType: Sample Collection,Collected By,Shromážděno podle
-apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,Hodnocení výsledků
+apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,Hodnocení výsledků
 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/item/item.js +60,Variant Details Report,Zpráva Variant Podrobnosti
 DocType: Setup Progress Action,Setup Progress Action,Pokročilé nastavení
+apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +18,Buying Price List,Nákupní ceník
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Odebrat pokud poplatků není pro tuto položku
+apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Zvolte Stav údržby jako Dokončené nebo odeberte datum dokončení
+DocType: Supplier,Default Payment Terms Template,Výchozí šablony platebních podmínek
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Měna transakce musí být stejná jako platební brána měnu
 DocType: Payment Entry,Receive,Příjem
 apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,citace:
@@ -4658,20 +4994,20 @@
 DocType: Workstation,Operating Costs,Provozní náklady
 DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Akční pokud souhrnné měsíční rozpočet překročen
 DocType: Subscription,Submit on creation,Předložení návrhu na vytvoření
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +469,Currency for {0} must be {1},Měna pro {0} musí být {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +470,Currency for {0} must be {1},Měna pro {0} musí být {1}
 DocType: Asset,Disposal Date,Likvidace Datum
 DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","E-maily budou zaslány všem aktivním zaměstnancům společnosti v danou hodinu, pokud nemají dovolenou. Shrnutí odpovědí budou zaslány do půlnoci."
 DocType: Employee Leave Approver,Employee Leave Approver,Zaměstnanec Leave schvalovač
-apps/erpnext/erpnext/stock/doctype/item/item.py +508,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/stock/doctype/item/item.py +485,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 +99,"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
 apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Trénink Feedback
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +458,Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +483,Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy
 DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kritéria dodavatele skóre karty
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,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/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Samozřejmě je povinné v řadě {0}
+apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Samozřejmě je povinné v řadě {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: Supplier Quotation Item,Prevdoc DocType,Prevdoc DOCTYPE
-apps/erpnext/erpnext/stock/doctype/item/item.js +272,Add / Edit Prices,Přidat / Upravit ceny
+apps/erpnext/erpnext/stock/doctype/item/item.js +268,Add / Edit Prices,Přidat / Upravit ceny
 DocType: Batch,Parent Batch,Nadřazená dávka
 DocType: Cheque Print Template,Cheque Print Template,Šek šablony tisku
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Diagram nákladových středisek
@@ -4680,7 +5016,6 @@
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +655,My Orders,Moje objednávky
 DocType: Price List,Price List Name,Ceník Jméno
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Každodenní práci Shrnutí pro {0}
-DocType: Employee Loan,Totals,Součty
 DocType: BOM,Manufacturing,Výroba
 ,Ordered Items To Be Delivered,"Objednané zboží, které mají být dodány"
 DocType: Account,Income,Příjem
@@ -4690,127 +5025,140 @@
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +266,Sales Invoice {0} has already been submitted,Prodejní faktury {0} již byla odeslána
 DocType: Supplier Scorecard Scoring Criteria,Score,Skóre
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Fiskální rok {0} neexistuje
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Dokončení Datum
+DocType: Asset Maintenance Log,Completion Date,Dokončení Datum
 DocType: Purchase Invoice Item,Amount (Company Currency),Částka (Měna Společnosti)
+DocType: Crop,Agriculture User,Zemědělský uživatel
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Platné do data nemůže být před datem transakce
-apps/erpnext/erpnext/stock/stock_ledger.py +372,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jednotek {1} zapotřebí {2} o {3} {4} na {5} pro dokončení této transakce.
+apps/erpnext/erpnext/stock/stock_ledger.py +379,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jednotek {1} zapotřebí {2} o {3} {4} na {5} pro dokončení této transakce.
 DocType: Fee Schedule,Student Category,Student Kategorie
 DocType: Announcement,Student,Student
-apps/erpnext/erpnext/config/hr.py +233,Organization unit (department) master.,Organizace jednotka (departement) master.
-apps/erpnext/erpnext/utilities/user_progress.py +218,Go to Rooms,Jděte do pokojů
+apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Organizace jednotka (departement) master.
+DocType: Shipping Rule,Shipping Rule Type,Typ pravidla přepravy
+apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Jděte do pokojů
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,"Prosím, zadejte zprávu před odesláním"
 DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLIKÁT PRO DODAVATELE
 DocType: Email Digest,Pending Quotations,Čeká na citace
-apps/erpnext/erpnext/config/accounts.py +326,Point-of-Sale Profile,Point-of-Sale Profil
+apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-of-Sale Profil
 apps/erpnext/erpnext/config/healthcare.py +153,Lab Test Configurations.,Konfigurace laboratorních testů.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Nezajištěných úvěrů
 DocType: Cost Center,Cost Center Name,Jméno nákladového střediska
-DocType: Employee,B+,B +
+DocType: Student,B+,B +
 DocType: HR Settings,Max working hours against Timesheet,Maximální pracovní doba proti časového rozvrhu
 DocType: Maintenance Schedule Detail,Scheduled Date,Plánované datum
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77,Total Paid Amt,Celkem uhrazeno Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +88,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,Obdrženo a přijato
 DocType: Hub Settings,Company and Seller Profile,Profil společnosti a prodávajícího
 ,GST Itemised Sales Register,GST Itemized Sales Register
+DocType: Soil Texture,Silt Loam,Silt Loam
 ,Serial No Service Contract Expiry,Pořadové číslo Servisní smlouva vypršení platnosti
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,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.
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +297,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: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Dospělý puls je v rozmezí od 50 do 80 úderů za minutu.
 DocType: Naming Series,Help HTML,Nápověda HTML
 DocType: Student Group Creation Tool,Student Group Creation Tool,Student Group Tool Creation
 DocType: Item,Variant Based On,Varianta založená na
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Celková weightage přiřazen by měla být 100%. Je {0}
-apps/erpnext/erpnext/utilities/user_progress.py +88,Your Suppliers,Vaši Dodavatelé
+apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,Vaši Dodavatelé
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Opravte prosím
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,"Nelze nastavit jako Ztraceno, protože je přijata objednávka."
 DocType: Request for Quotation Item,Supplier Part No,Žádný dodavatel Part
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +365,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nemůže odečíst, pokud kategorie je pro &quot;ocenění&quot; nebo &quot;Vaulation a Total&quot;"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +363,Received From,Přijaté Od
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nemůže odečíst, pokud kategorie je pro &quot;ocenění&quot; nebo &quot;Vaulation a Total&quot;"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Received From,Přijaté 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 +24,{0}: From {0} for {1},{0}: Od {0} do {1}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +219,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Podle nákupních nastavení, pokud je požadováno nákupní požadavek == &#39;ANO&#39;, pak pro vytvoření nákupní faktury musí uživatel nejprve vytvořit doklad o nákupu pro položku {0}"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +166,Row #{0}: Set Supplier for item {1},Řádek # {0}: Nastavte Dodavatel pro položku {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Podle nákupních nastavení, pokud je požadováno nákupní požadavek == &#39;ANO&#39;, pak pro vytvoření nákupní faktury musí uživatel nejprve vytvořit doklad o nákupu pro položku {0}"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Řádek # {0}: Nastavte Dodavatel pro položku {1}
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Řádek {0}: doba hodnota musí být větší než nula.
-apps/erpnext/erpnext/stock/doctype/item/item.py +183,Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} připojuje k bodu {1} nelze nalézt
+apps/erpnext/erpnext/stock/doctype/item/item.py +185,Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} připojuje k bodu {1} nelze nalézt
 DocType: Issue,Content Type,Typ obsahu
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,Počítač
+DocType: Asset,Assets,Aktiva
+apps/erpnext/erpnext/setup/setup_wizard/data/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/healthcare/doctype/patient/patient.py +82,Please set default customer group and territory in Selling Settings,Nastavte výchozí skupinu zákazníků a území v nastavení prodeje
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,"Prosím, zkontrolujte více měn možnost povolit účty s jinou měnu"
+DocType: Payment Term,Due Date Based On,Datum splatnosti založeno na
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Nastavte výchozí skupinu zákazníků a území v nastavení prodeje
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +203,{0} {1} does not exist,{0} {1} neexistuje
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +321,Please check Multi Currency option to allow accounts with other currency,"Prosím, zkontrolujte více měn možnost povolit účty s jinou měnu"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +85,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í
+apps/erpnext/erpnext/accounts/doctype/account/account.py +108,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 faktury Datum
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +28,You don't have permission to submit,Nemáte oprávnění k odeslání
-apps/erpnext/erpnext/accounts/party.py +268,Billing currency must be equal to either default comapany's currency or party account currency,Fakturační měna se musí rovnat měny nebo účtu strana peněz buď výchozího comapany je
 DocType: Healthcare Settings,Laboratory Settings,Laboratorní nastavení
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +71,Leave Encashment,Nechat inkasa
-apps/erpnext/erpnext/public/js/setup_wizard.js +111,What does it do?,Co to dělá?
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +75,To Warehouse,Do skladu
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +26,All Student Admissions,Všechny Student Přijímací
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Nechat inkasa
+apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Co to dělá?
+DocType: Crop,Byproducts,Vedlejší produkty
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +76,To Warehouse,Do skladu
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Všechny Student Přijímací
 ,Average Commission Rate,Průměrná cena Komise
-apps/erpnext/erpnext/stock/doctype/item/item.py +418,'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemůže být ""Ano"" pro neskladové zboží"
+apps/erpnext/erpnext/stock/doctype/item/item.py +434,'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemůže být ""Ano"" pro neskladové zboží"
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Vyberte možnost Stav
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,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: School House,House Name,Jméno dům
 DocType: Fee Schedule,Total Amount per Student,Celková částka na jednoho studenta
 DocType: Purchase Taxes and Charges,Account Head,Účet Head
-apps/erpnext/erpnext/config/stock.py +173,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 +149,Electrical,Elektrický
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Elektrický
 apps/erpnext/erpnext/utilities/activation.py +100,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,"Přidejte zbytek vaší organizace jako uživatele. Můžete také přidat pozvat zákazníky na portálu tím, že přidáním z Kontaktů"
 DocType: Stock Entry,Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Řádek {0}: Exchange Rate je povinné
+DocType: Grant Application,Requested Amount,Požadovaná částka
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +346,Row {0}: Exchange Rate is mandatory,Řádek {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: Vehicle,Vehicle Value,Hodnota vozidla
+DocType: Crop Cycle,Detected Diseases,Zjištěné nemoci
 DocType: Stock Entry,Default Source Warehouse,Výchozí zdrojový sklad
 DocType: Item,Customer Code,Code zákazníků
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +216,Birthday Reminder for {0},Narozeninová připomínka pro {0}
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Narozeninová připomínka pro {0}
+DocType: Asset Maintenance Task,Last Completion Date,Poslední datum dokončení
 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 +355,Debit To account must be a Balance Sheet account,Debetní Na účet musí být účtu Rozvaha
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +359,Debit To account must be a Balance Sheet account,Debetní Na účet musí být účtu Rozvaha
 DocType: Buying Settings,Naming Series,Číselné řady
 DocType: Leave Block List,Leave Block List Name,Nechte Jméno Block List
 apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Datum pojištění startu by měla být menší než pojištění koncovým datem
-apps/erpnext/erpnext/schools/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in School &gt; School Settings,Nastavte prosím systém instruktorů ve škole&gt; Nastavení školy
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Stock Aktiva
 DocType: Timesheet,Production Detail,výroba Detail
 DocType: Restaurant,Active Menu,Aktivní nabídka
 DocType: Target Detail,Target Qty,Target Množství
 DocType: Shopping Cart Settings,Checkout Settings,Pokladna Nastavení
-DocType: Attendance,Present,Současnost
+DocType: Student Attendance,Present,Současnost
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Delivery Note {0} nesmí být předloženy
 DocType: Notification Control,Sales Invoice Message,Prodejní faktury Message
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Závěrečný účet {0} musí být typu odpovědnosti / Equity
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325,Salary Slip of employee {0} already created for time sheet {1},Výplatní pásce zaměstnance {0} již vytvořili pro časové list {1}
 DocType: Vehicle Log,Odometer,Počítadlo ujetých kilometrů
 DocType: Sales Order Item,Ordered Qty,Objednáno Množství
-apps/erpnext/erpnext/stock/doctype/item/item.py +727,Item {0} is disabled,Položka {0} je zakázána
+apps/erpnext/erpnext/stock/doctype/item/item.py +713,Item {0} is disabled,Položka {0} je zakázána
 DocType: Stock Settings,Stock Frozen Upto,Reklamní Frozen aľ
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +904,BOM does not contain any stock item,BOM neobsahuje žádnou skladovou položku
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +929,BOM does not contain any stock item,BOM neobsahuje žádnou skladovou položku
+DocType: Chapter,Chapter Head,Hlava kapitoly
+DocType: Payment Term,Month(s) after the end of the invoice month,Měsíc (měsíce) po skončení měsíce faktury
 apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Projektová činnost / úkol.
 DocType: Vehicle Log,Refuelling Details,Tankovací Podrobnosti
 apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Generování výplatních páskách
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"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: Shipping Rule,Restrict to Countries,Omezte na země
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +171,Select Delivery Notes,Vyberte poznámky o doručení
 DocType: Purchase Invoice,Write Off Amount (Company Currency),Odepsat Částka (Company měny)
 DocType: Sales Invoice Timesheet,Billing Hours,Billing Hodiny
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +500,Default BOM for {0} not found,Výchozí BOM pro {0} nebyl nalezen
-apps/erpnext/erpnext/stock/doctype/item/item.py +498,Row #{0}: Please set reorder quantity,Řádek # {0}: Prosím nastavte množství objednací
+DocType: Project,Total Sales Amount (via Sales Order),Celková částka prodeje (prostřednictvím objednávky prodeje)
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +528,Default BOM for {0} not found,Výchozí BOM pro {0} nebyl nalezen
+apps/erpnext/erpnext/stock/doctype/item/item.py +489,Row #{0}: Please set reorder quantity,Řádek # {0}: Prosím nastavte množství objednací
 apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Klepnutím na položky je můžete přidat zde
 DocType: Fees,Program Enrollment,Registrace do programu
 DocType: Landed Cost Voucher,Landed Cost Voucher,Přistálo Náklady Voucher
 apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Prosím nastavte {0}
-apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} je neaktivní student
+apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} je neaktivní student
 DocType: Employee,Health Details,Zdravotní Podrobnosti
 DocType: Offer Letter,Offer Letter Terms,Nabídka Letter Podmínky
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,"Chcete-li vytvořit referenční dokument žádosti o platbu, je třeba"
+DocType: Soil Texture,Sandy Clay,Sandy Clay
+DocType: Grant Application,Assessment  Manager,Správce hodnocení
 DocType: Payment Entry,Allocate Payment Amount,Přidělit částku platby
 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í
 DocType: Sales Order,Partly Delivered,Částečně vyhlášeno
+DocType: Item Variant Settings,Do not update variants on save,Neaktualizujte varianty při ukládání
 DocType: Email Digest,Receivables,Pohledávky
 DocType: Lead Source,Lead Source,Olovo Source
 DocType: Customer,Additional information regarding the customer.,Další informace týkající se zákazníka.
@@ -4821,24 +5169,27 @@
 DocType: Maintenance Visit,Maintenance Date,Datum údržby
 DocType: Purchase Invoice Item,Rejected Serial No,Odmítnuté sériové číslo
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,Rok datum zahájení nebo ukončení se překrývá s {0}. Aby se zabránilo nastavte firmu
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +94,Please mention the Lead Name in Lead {0},Uvedete prosím vedoucí jméno ve vedoucím {0}
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +108,Please mention the Lead Name in Lead {0},Uvedete prosím vedoucí jméno ve vedoucím {0}
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,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át Návštěvnost
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +319,BOM and Manufacturing Quantity are required,BOM a výroba množství jsou povinné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +535,BOM and Manufacturing Quantity are required,BOM a výroba množství jsou povinné
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Stárnutí rozsah 2
 DocType: SG Creation Tool Course,Max Strength,Max Síla
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Instalace předvoleb
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +67,No Delivery Note selected for Customer {},Pro zákazníka nebyl vybrán žádný zákazník {}
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,BOM nahradil
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +992,Select Items based on Delivery Date,Vyberte položky podle data doručení
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Select Items based on Delivery Date,Vyberte položky podle data doručení
+DocType: Grant Application,Has any past Grant Record,Má nějaký minulý grantový záznam
 ,Sales Analytics,Prodejní Analytics
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +119,Available {0},K dispozici {0}
 ,Prospects Engaged But Not Converted,"Perspektivy zapojení, ale nekonverze"
 DocType: Manufacturing Settings,Manufacturing Settings,Výrobní nastavení
 apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Nastavení e-mail
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobile Žádné
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +103,Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobile Žádné
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr
 DocType: Stock Entry Detail,Stock Entry Detail,Detail pohybu na skladu
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Denní Upomínky
 DocType: Products Settings,Home Page is Products,Domovskou stránkou je stránka Produkty.
@@ -4847,17 +5198,17 @@
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Nový název účtu
 DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Dodává se nákladů na suroviny
 DocType: Selling Settings,Settings for Selling Module,Nastavení pro prodej Module
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +111,Customer Service,Služby zákazníkům
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Služby zákazníkům
 DocType: BOM,Thumbnail,Thumbnail
 DocType: Item Customer Detail,Item Customer Detail,Položka Detail Zákazník
 apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Nabídka 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 +88,Total allocated leaves are more than days in the period,Celkové přidělené listy jsou více než dnů v období
+DocType: Land Unit,Linked Soil Analysis,Analýza propojené půdy
 DocType: Pricing Rule,Percentage,Procento
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Položka {0} musí být skladem
 DocType: Manufacturing Settings,Default Work In Progress Warehouse,Výchozí práci ve skladu Progress
-apps/erpnext/erpnext/config/accounts.py +296,Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +23,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosím, nastavte systém pro pojmenování zaměstnanců v oblasti lidských zdrojů&gt; Nastavení HR"
+apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
 DocType: Maintenance Visit,MV,MV
 DocType: Restaurant,Default Tax Template,Výchozí daňová šablona
 DocType: Fees,Student Details,Podrobnosti studenta
@@ -4866,15 +5217,15 @@
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Chyba: Není platný id?
 DocType: Naming Series,Update Series Number,Aktualizace Series Number
 DocType: Account,Equity,Hodnota majetku
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: &quot;výkaz zisků a ztrát&quot; typ účtu {2} není povolen vstup do Otevírací Entry
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,"{0} {1}: ""výkaz zisků a ztrát"" typ účtu {2} není povolen do Otevírací vstup"
 DocType: Sales Order,Printing Details,Tisk detailů
 DocType: Task,Closing Date,Uzávěrka Datum
 DocType: Sales Order Item,Produced Quantity,Produkoval Množství
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +122,Engineer,Inženýr
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Inženýr
 DocType: Journal Entry,Total Amount Currency,Celková částka Měna
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Vyhledávání Sub Assemblies
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +168,Item Code required at Row No {0},Kód položky třeba na řádku č {0}
-apps/erpnext/erpnext/utilities/user_progress.py +133,Go to Items,Přejděte na položky
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Kód položky třeba na řádku č {0}
+apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Přejděte na položky
 DocType: Sales Partner,Partner Type,Partner Type
 DocType: Purchase Taxes and Charges,Actual,Aktuální
 DocType: Restaurant Menu,Restaurant Manager,Manažer restaurace
@@ -4891,35 +5242,37 @@
 DocType: Item Reorder,Re-Order Level,Úroveň pro znovuobjednání
 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žku a požadované množství ks, které chcete zadat do výroby, nebo si stáhněte soupis materiálu na skladu pro výrobu."
 apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Pruhový diagram
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +95,Part-time,Part-time
+DocType: Crop Cycle,Cycle Type,Typ cyklu
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Part-time
 DocType: Employee,Applicable Holiday List,Použitelný Seznam Svátků
 DocType: Employee,Cheque,Šek
 DocType: Training Event,Employee Emails,E-maily zaměstnanců
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,Řada Aktualizováno
-apps/erpnext/erpnext/accounts/doctype/account/account.py +162,Report Type is mandatory,Report Type je povinné
+apps/erpnext/erpnext/accounts/doctype/account/account.py +161,Report Type is mandatory,Report Type je povinné
 DocType: Item,Serial Number Series,Sériové číslo Series
 apps/erpnext/erpnext/buying/utils.py +68,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
+apps/erpnext/erpnext/setup/setup_wizard/data/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 +90,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/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Světlá Datum aktualizováno
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +131,Split Batch,Split Batch
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +138,Split Batch,Split Batch
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Úspěšně smířeni
 DocType: Request for Quotation Supplier,Download PDF,Stáhnout PDF
 DocType: Production Order,Planned End Date,Plánované datum ukončení
-apps/erpnext/erpnext/controllers/buying_controller.py +423,Please enter Schedule Date,Zadejte prosím datum rozvrhu
-apps/erpnext/erpnext/config/stock.py +189,Where items are stored.,"Tam, kde jsou uloženy předměty."
+apps/erpnext/erpnext/controllers/buying_controller.py +424,Please enter Schedule Date,Zadejte prosím datum rozvrhu
+apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informace o typu dárce.
 DocType: Request for Quotation,Supplier Detail,dodavatel Detail
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Chyba ve vzorci nebo stavu: {0}
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Fakturovaná částka
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Kritéria váhy musí obsahovat až 100%
-DocType: Attendance,Attendance,Účast
+apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Účast
 apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,sklade
 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/accounts/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Zdrojové a cílové skladů nemohou být stejné
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +535,Posting date and posting time is mandatory,Datum a čas zadání je povinný
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +103,Creating {0},Vytváření {0}
+apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Zdrojové a cílové skladů nemohou být stejné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +561,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."
@@ -4929,39 +5282,42 @@
 apps/erpnext/erpnext/config/selling.py +67,Price List master.,Ceník master.
 DocType: Task,Review Date,Review Datum
 DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Série pro odepisování aktiv (Entry Entry)
+DocType: Membership,Member Since,Členem od
 DocType: Purchase Invoice,Advance Payments,Zálohové platby
 DocType: Purchase Taxes and Charges,On Net Total,On Net Celkem
 apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Hodnota atributu {0} musí být v rozmezí od {1} až {2} v krocích po {3} pro item {4}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,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/stock/doctype/stock_entry/stock_entry.py +166,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
 DocType: Restaurant Reservation,Waitlisted,Vyčkejte
-apps/erpnext/erpnext/accounts/doctype/account/account.py +127,Currency can not be changed after making entries using some other currency,Měna nemůže být změněn po provedení položky pomocí jiné měně
+apps/erpnext/erpnext/accounts/doctype/account/account.py +126,Currency can not be changed after making entries using some other currency,Měna nemůže být změněn po provedení položky pomocí jiné měně
+DocType: Shipping Rule,Fixed,Pevný
 DocType: Vehicle Service,Clutch Plate,Kotouč spojky
 DocType: Company,Round Off Account,Zaokrouhlovací účet
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Administrativní náklady
-apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,Consulting
+apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Consulting
 DocType: Customer Group,Parent Customer Group,Parent Customer Group
 DocType: Journal Entry,Subscription,Předplatné
 DocType: Purchase Invoice,Contact Email,Kontaktní e-mail
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Vytváření poplatků čeká
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Vytváření poplatků čeká
 DocType: Appraisal Goal,Score Earned,Skóre Zasloužené
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +229,Notice Period,Výpovědní Lhůta
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Notice Period,Výpovědní Lhůta
 DocType: Asset Category,Asset Category Name,Asset název kategorie
 apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,To je kořen území a nelze upravovat.
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Jméno Nová Sales Osoba
 DocType: Packing Slip,Gross Weight UOM,Hrubá Hmotnost UOM
+DocType: Asset Maintenance Task,Preventive Maintenance,Preventivní údržba
 DocType: Delivery Note Item,Against Sales Invoice,Proti prodejní faktuře
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +141,Please enter serial numbers for serialized item ,Zadejte sériová čísla pro serializovanou položku
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Zadejte sériová čísla pro serializovanou položku
 DocType: Bin,Reserved Qty for Production,Vyhrazeno Množství pro výrobu
 DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Ponechte nekontrolované, pokud nechcete dávat pozor na dávku při sestavování kurzových skupin."
 DocType: Asset,Frequency of Depreciation (Months),Frekvence odpisy (měsíce)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +493,Credit Account,Úvěrový účet
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +501,Credit Account,Úvěrový účet
 DocType: Landed Cost Item,Landed Cost Item,Přistálo nákladovou položkou
 apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,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: Lab Test,Test Group,Testovací skupina
 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 +694,Please specify Attribute Value for attribute {0},Uveďte prosím atributu Hodnota atributu {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +680,Please specify Attribute Value for attribute {0},Uveďte prosím atributu Hodnota atributu {0}
 DocType: Item,Default Warehouse,Výchozí sklad
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Rozpočet nemůže být přiřazena na skupinový účet {0}
 DocType: Healthcare Settings,Patient Registration,Registrace pacienta
@@ -4973,23 +5329,27 @@
 DocType: Appraisal,Total Score (Out of 5),Celkové skóre (Out of 5)
 DocType: Fee Structure,FS.,FS.
 DocType: Student Attendance Tool,Batch,Šarže
+DocType: Donor,Donor Type,Typ dárce
 apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Zůstatek
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Vyberte prosím společnost
 DocType: Room,Seating Capacity,Počet míst k sezení
 DocType: Issue,ISS-,ISS-
 DocType: Lab Test Groups,Lab Test Groups,Laboratorní testovací skupiny
 DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nároků)
 DocType: GST Settings,GST Summary,Souhrn GST
 DocType: Assessment Result,Total Score,Celkové skóre
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +116,Please set the Default Cost Center in {0} company,Nastavte výchozí cenové centrum ve společnosti {0}
 DocType: Journal Entry,Debit Note,Debit Note
 DocType: Stock Entry,As per Stock UOM,Podle Stock nerozpuštěných
 apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Neuplynula
 DocType: Student Log,Achievement,Úspěch
 DocType: Batch,Source Document Type,Zdrojový typ dokumentu
+apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Byly vytvořeny následující kurzy
 DocType: Journal Entry,Total Debit,Celkem Debit
 DocType: Manufacturing Settings,Default Finished Goods Warehouse,Výchozí sklad hotových výrobků
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +77,Sales Person,Prodej Osoba
-apps/erpnext/erpnext/config/accounts.py +241,Budget and Cost Center,Rozpočet a nákladového střediska
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +60,Multiple default mode of payment is not allowed,Vícenásobný výchozí způsob platby není povolen
+apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Rozpočet a nákladového střediska
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Vícenásobný výchozí způsob platby není povolen
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,pro
 ,Appointment Analytics,Aplikace Analytics
 DocType: Vehicle Service,Half Yearly,Pololetní
@@ -4998,17 +5358,18 @@
 DocType: Healthcare Settings,Consultations in valid days,Konzultace v platných dnech
 DocType: Assessment Plan Criteria,Maximum Score,Maximální skóre
 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.
-apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Skup
-apps/erpnext/erpnext/schools/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Vytvoření poplatku se nezdařilo
+apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Skup
+apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Vytvoření poplatku se nezdařilo
 DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Nechte prázdné, pokud rodíte studentské skupiny ročně"
 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/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Změnit kód šablony
-apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Termínovaný Datum ukončení nesmí být starší než Počáteční datum doby platnosti. Opravte data a zkuste to znovu.
+apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Termínovaný Datum ukončení nesmí být starší než Počáteční datum doby platnosti. Opravte data a zkuste to znovu.
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Počet kvotů
 ,BOM Stock Report,BOM Sklad Zpráva
 DocType: Stock Reconciliation Item,Quantity Difference,množství Rozdíl
-apps/erpnext/erpnext/config/hr.py +315,Processing Payroll,Zpracování mezd
+DocType: Employee Advance,EA-,EA-
+apps/erpnext/erpnext/config/hr.py +320,Processing Payroll,Zpracování mezd
 DocType: Opportunity Item,Basic Rate,Basic Rate
 DocType: GL Entry,Credit Amount,Výše úvěru
 DocType: Cheque Print Template,Signatory Position,Signatář Position
@@ -5016,7 +5377,7 @@
 DocType: Timesheet,Total Billable Hours,Celkem zúčtovatelné hodiny
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Doklad o zaplacení Note
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,To je založeno na transakcích proti tomuto zákazníkovi. Viz časovou osu níže podrobnosti
-DocType: Supplier,Credit Days Based On,Úvěrové Dny Based On
+DocType: Company,Credit Days Based On,Úvěrové Dny Based On
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Řádek {0}: Přidělená částka {1} musí být menší než nebo se rovná částce zaplacení výstavního {2}
 ,Course wise Assessment Report,Průběžná hodnotící zpráva
 DocType: Tax Rule,Tax Rule,Daňové Pravidlo
@@ -5024,66 +5385,73 @@
 DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovních hodin.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +92,Dr {0} does not have a Physician Schedule. Add it in Physician master,Doktor {0} nemá plán lékařů. Přidejte jej do mistra lékaře
 apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Zákazníci ve frontě
+DocType: Driver,Issuing Date,Datum vydání
 DocType: Student,Nationality,Národnost
 ,Items To Be Requested,Položky se budou vyžadovat
 DocType: Company,Company Info,Společnost info
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1359,Select or add new customer,Vyberte nebo přidání nového zákazníka
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +154,Cost center is required to book an expense claim,Nákladové středisko je nutné rezervovat výdajů nárok
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1374,Select or add new customer,Vyberte nebo přidání nového zákazníka
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +179,Cost center is required to book an expense claim,Nákladové středisko je nutné rezervovat výdajů nárok
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Aplikace fondů (aktiv)
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,To je založeno na účasti základu tohoto zaměstnance
-apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Označit účast
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +487,Debit Account,Debetní účet
+apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Označit účast
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +495,Debit Account,Debetní účet
 DocType: Fiscal Year,Year Start Date,Datum Zahájení Roku
 DocType: Attendance,Employee Name,Jméno zaměstnance
 DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Položka objednávky restaurace
-DocType: Sales Invoice,Rounded Total (Company Currency),Celkem zaokrouhleno (měna solečnosti)
-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."
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +240,{0} {1} has been modified. Please refresh.,{0} {1} byl změněn. Prosím aktualizujte.
+DocType: Purchase Invoice,Rounded Total (Company Currency),Celkem zaokrouhleno (měna solečnosti)
+apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} byl změněn. 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.
+DocType: Asset Maintenance Team,Maintenance Team Members,Členové týmu údržby
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Částka nákupu
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Dodavatel Cen {0} vytvořil
 apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Konec roku nemůže být před uvedením do provozu roku
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +222,Employee Benefits,Zaměstnanecké benefity
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Employee Benefits,Zaměstnanecké benefity
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,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í
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Faktura byla vytvořena
+DocType: Asset,Out of Order,Mimo provoz
 DocType: Purchase Receipt Item,Accepted Quantity,Schválené Množství
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Please set a default Holiday List for Employee {0} or Company {1},Prosím nastavit výchozí Holiday List pro zaměstnance {0} nebo {1} Company
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},Prosím nastavit výchozí Holiday List pro zaměstnance {0} nebo {1} Company
 apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0}: {1} neexistuje
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +75,Select Batch Numbers,Zvolte čísla šarží
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Zvolte čísla šarží
 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 +534,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},"Řádek č {0}: Částka nemůže být větší než Čekající Částka proti Expense nároku {1}. Do doby, než množství je {2}"
-DocType: Maintenance Schedule,Schedule,Plán
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +532,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},"Řádek č {0}: Částka nemůže být větší než Čekající Částka proti Expense nároku {1}. Do doby, než množství je {2}"
+DocType: Assessment Plan,Schedule,Plán
 DocType: Account,Parent Account,Nadřazený účet
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +253,Available,K dispozici
+apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,K dispozici
 DocType: Quality Inspection Reading,Reading 3,Čtení 3
 ,Hub,Hub
 DocType: GL Entry,Voucher Type,Voucher Type
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1691,Price List not found or disabled,Ceník nebyl nalezen nebo zakázán
-DocType: Lab Test,Approved,Schválený
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1706,Price List not found or disabled,Ceník nebyl nalezen nebo zakázán
+DocType: Student Applicant,Approved,Schválený
 DocType: Pricing Rule,Price,Cena
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',"Zaměstnanec úlevu na {0} musí být nastaven jako ""Left"""
 DocType: Hub Settings,Last Sync On,Poslední synchronizace je zapnutá
 DocType: Guardian,Guardian,poručník
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,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: Academic Term,Education,Vzdělání
 apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,Del
 DocType: Selling Settings,Campaign Naming By,Kampaň Pojmenování By
 DocType: Employee,Current Address Is,Aktuální adresa je
 apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Měsíční prodejní cíl (
 apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,Upravené
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +41,"Optional. Sets company's default currency, if not specified.","Volitelné. Nastaví výchozí měně společnosti, není-li uvedeno."
+apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Volitelné. Nastaví výchozí měně společnosti, není-li uvedeno."
 DocType: Sales Invoice,Customer GSTIN,Zákazník GSTIN
+DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Seznam onemocnění zjištěných v terénu. Když je vybráno, automaticky přidá seznam úkolů, které se mají vypořádat s tímto onemocněním"
+DocType: Asset Repair,Repair Status,Stav opravy
 apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Zápisy v účetním deníku.
 DocType: Delivery Note Item,Available Qty at From Warehouse,K dispozici Množství na Od Warehouse
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,"Prosím, vyberte zaměstnance záznam první."
 DocType: POS Profile,Account for Change Amount,Účet pro změnu Částka
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Řádek {0}: Party / Account neshoduje s {1} / {2} do {3} {4}
-apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kód předmětu:
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +215,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Řádek {0}: Party / Account neshoduje s {1} / {2} do {3} {4}
+DocType: Maintenance Team Member,Maintenance Team Member,Člen týmu údržby
+DocType: Agriculture Analysis Criteria,Soil Analysis,Analýza půd
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kód předmětu:
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,"Prosím, zadejte výdajového účtu"
 DocType: Account,Stock,Sklad
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1042,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Řádek # {0}: Reference Document Type musí být jedním z objednávky, faktury nebo Journal Entry"
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Řádek # {0}: Reference Document Type musí být jedním z objednávky, faktury nebo Journal Entry"
 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
@@ -5094,53 +5462,52 @@
 DocType: Sales Invoice Item,Discount and Margin,Sleva a Margin
 DocType: Lab Test,Prescription,Předpis
 DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,"Prodejní Pull zakázky (čeká dodat), na základě výše uvedených kritérií"
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +90,Not Available,Není k dispozici
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Není k dispozici
 DocType: Pricing Rule,Min Qty,Min Množství
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Zakázat šablonu
-DocType: Asset Movement,Transaction Date,Transakce Datum
+DocType: GL Entry,Transaction Date,Transakce Datum
 DocType: Production Plan Item,Planned Qty,Plánované Množství
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total Tax
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177,For Quantity (Manufactured Qty) is mandatory,Pro Množství (Vyrobeno ks) je povinné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +182,For Quantity (Manufactured Qty) is mandatory,Pro Množství (Vyrobeno ks) je povinné
 DocType: Stock Entry,Default Target Warehouse,Výchozí cílový sklad
 DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Company Měna)
-apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Rok Datum ukončení nesmí být starší než datum Rok Start. Opravte data a zkuste to znovu.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Řádek {0}: Typ Party Party a je použitelná pouze proti pohledávky / závazky účtu
+apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Rok Datum ukončení nesmí být starší než datum Rok Start. Opravte data a zkuste to znovu.
 DocType: Notification Control,Purchase Receipt Message,Zpráva příjemky
 DocType: BOM,Scrap Items,šrot položky
 DocType: Production Order,Actual Start Date,Skutečné datum zahájení
 DocType: Sales Order,% of materials delivered against this Sales Order,% materiálů doručeno proti této prodejní objednávce
-apps/erpnext/erpnext/config/stock.py +12,Record item movement.,Záznam pohybu položka.
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +57,Set default mode of payment,Nastavte výchozí způsob platby
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Nastavte výchozí způsob platby
+DocType: Grant Application,Withdrawn,uzavřený
 DocType: Hub Settings,Hub Settings,Nastavení Hub
 DocType: Project,Gross Margin %,Hrubá Marže %
 DocType: BOM,With Operations,S operacemi
-apps/erpnext/erpnext/accounts/party.py +264,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,"Položky účetnictví již byly provedeny v měně, {0} pro firmu {1}. Vyberte pohledávky a závazku účet s měnou {0}."
+apps/erpnext/erpnext/accounts/party.py +262,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,"Položky účetnictví již byly provedeny v měně, {0} pro firmu {1}. Vyberte pohledávky a závazku účet s měnou {0}."
 DocType: Asset,Is Existing Asset,Je existujícímu aktivu
 DocType: Salary Detail,Statistical Component,Statistická složka
 DocType: Warranty Claim,If different than customer address,Pokud se liší od adresy zákazníka
 DocType: Purchase Invoice,Without Payment of Tax,Bez placení daně
 DocType: BOM Operation,BOM Operation,BOM Operation
+apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Splnění
 DocType: Purchase Taxes and Charges,On Previous Row Amount,Na předchozí řady Částka
-DocType: Student,Home Address,Domácí adresa
 DocType: Item,Has Expiry Date,Má datum vypršení platnosti
-apps/erpnext/erpnext/config/stock.py +111,Item Variant Settings.,Nastavení varianty položky.
-apps/erpnext/erpnext/accounts/doctype/asset/asset.js +249,Transfer Asset,Převod majetku
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +269,Transfer Asset,Převod majetku
 DocType: POS Profile,POS Profile,POS Profile
 DocType: Training Event,Event Name,Název události
 DocType: Physician,Phone (Office),Telefon (kancelář)
-apps/erpnext/erpnext/hooks.py +147,Admission,Přijetí
-apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +29,Admissions for {0},Přijímací řízení pro {0}
-apps/erpnext/erpnext/config/accounts.py +265,"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
+apps/erpnext/erpnext/hooks.py +151,Admission,Přijetí
+apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Přijímací řízení pro {0}
+apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
 DocType: Supplier Scorecard Scoring Variable,Variable Name,Název proměnné
-apps/erpnext/erpnext/stock/get_item_details.py +147,"Item {0} is a template, please select one of its variants","Položka {0} je šablona, prosím vyberte jednu z jeho variant"
+apps/erpnext/erpnext/stock/get_item_details.py +142,"Item {0} is a template, please select one of its variants","Položka {0} je šablona, prosím vyberte jednu z jeho variant"
 DocType: Asset,Asset Category,Asset Kategorie
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Net plat nemůže být záporný
 DocType: Assessment Plan,Room,Pokoj
 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 +843,Material to Supplier,Materiál Dodavateli
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +384,Excise Invoice,Spotřební Faktura
-apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Práh {0}% objeví více než jednou
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +868,Material to Supplier,Materiál Dodavateli
+DocType: Soil Texture,Loamy Sand,Loamy Sand
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +594,Excise Invoice,Spotřební Faktura
+apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Práh {0}% objeví více než jednou
 DocType: Expense Claim,Employees Email Id,Zaměstnanci Email Id
 DocType: Employee Attendance Tool,Marked Attendance,Výrazná Návštěvnost
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Krátkodobé závazky
@@ -5148,16 +5515,17 @@
 DocType: Patient,A Positive,Pozitivní
 DocType: Program,Program Name,Název programu
 DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Zvažte daň či poplatek za
+DocType: Driver,Driving License Category,Kategorie řidičských oprávnění
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Skutečné Množství je povinné
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +80,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} v současné době disponuje {1} hodnotící tabulkou dodavatelů a objednávky na nákup tohoto dodavatele by měly být vydány s opatrností.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} v současné době disponuje {1} hodnotící tabulkou dodavatelů a objednávky na nákup tohoto dodavatele by měly být vydány s opatrností.
+DocType: Asset Maintenance Team,Asset Maintenance Team,Tým pro údržbu aktiv
 DocType: Employee Loan,Loan Type,Typ úvěru
 DocType: Scheduling Tool,Scheduling Tool,Plánování Tool
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +176,Credit Card,Kreditní karta
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Kreditní karta
 DocType: BOM,Item to be manufactured or repacked,Položka k výrobě nebo zabalení
-apps/erpnext/erpnext/config/stock.py +184,Default settings for stock transactions.,Výchozí nastavení pro akciových transakcí.
 DocType: Employee Education,Major/Optional Subjects,Hlavní / Volitelné předměty
 DocType: Sales Invoice Item,Drop Ship,Drop Loď
-DocType: Hub Settings,Suspended,Pozastaveno
+DocType: Driver,Suspended,Pozastaveno
 DocType: Training Event,Attendees,Účastníci
 DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Zde si můžete udržovat rodinné detailů, jako jsou jméno a povolání rodičem, manželem a dětmi"
 DocType: Academic Term,Term End Date,Termín Datum ukončení
@@ -5166,13 +5534,13 @@
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Z měny a měny nemůže být stejné
 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
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +96,Please select the Company first,Nejprve vyberte společnost
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Nejprve vyberte společnost
 DocType: Item Attribute,Numeric Values,Číselné hodnoty
-apps/erpnext/erpnext/public/js/setup_wizard.js +52,Attach Logo,Připojit Logo
+apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Připojit Logo
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +43,Stock Levels,Sklad Úrovně
 DocType: Customer,Commission Rate,Výše provize
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Vytvořili {0} skóre pro {1} mezi:
-apps/erpnext/erpnext/stock/doctype/item/item.js +346,Make Variant,Udělat Variant
+apps/erpnext/erpnext/stock/doctype/item/item.js +472,Make Variant,Udělat Variant
 apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Aplikace Block dovolené podle oddělení.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +144,"Payment Type must be one of Receive, Pay and Internal Transfer",Typ platby musí být jedním z příjem Pay a interní převod
 apps/erpnext/erpnext/config/selling.py +179,Analytics,analytika
@@ -5180,7 +5548,8 @@
 DocType: Vehicle,Model,Model
 DocType: Production Order,Actual Operating Cost,Skutečné provozní náklady
 DocType: Payment Entry,Cheque/Reference No,Šek / Referenční číslo
-apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root cannot be edited.,Root nelze upravovat.
+DocType: Soil Texture,Clay Loam,Clay Loam
+apps/erpnext/erpnext/accounts/doctype/account/account.py +83,Root cannot be edited.,Root nelze upravovat.
 DocType: Item,Units of Measure,Jednotky měření
 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
@@ -5193,39 +5562,37 @@
 DocType: Company,Existing Company,stávající Company
 DocType: Healthcare Settings,Result Emailed,Výsledkem byl emailem
 apps/erpnext/erpnext/controllers/buying_controller.py +84,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Daňová kategorie byla změněna na &quot;Celkem&quot;, protože všechny položky jsou položky, které nejsou skladem"
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položek&gt; Značka
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Vyberte soubor csv
 DocType: Student Leave Application,Mark as Present,Označit jako dárek
 DocType: Supplier Scorecard,Indicator Color,Barva indikátoru
 DocType: Purchase Order,To Receive and Bill,Přijímat a Bill
 apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,představované výrobky
-apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +132,Designer,Návrhář
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Návrhář
 apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Podmínky Template
 DocType: Serial No,Delivery Details,Zasílání
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +487,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 +491,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}
 DocType: Program,Program Code,Kód programu
 DocType: Terms and Conditions,Terms and Conditions Help,Podmínky nápovědy
 ,Item-wise Purchase Register,Item-wise registr nákupu
-DocType: Batch,Expiry Date,Datum vypršení platnosti
+DocType: Driver,Expiry Date,Datum vypršení platnosti
 DocType: Healthcare Settings,Employee name and designation in print,Jméno a označení zaměstnance v tisku
 ,accounts-browser,Účty-browser
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +351,Please select Category first,Nejdřív vyberte kategorii
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Nejdřív vyberte kategorii
 apps/erpnext/erpnext/config/projects.py +13,Project master.,Master Project.
 apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Chcete-li povolit over-fakturaci nebo over-objednávání, aktualizujte &quot;příspěvek&quot; v Nastavení skladem, nebo výtisku."
 DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Nevykazují žádný symbol jako $ atd vedle měnám.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +459, (Half Day),(půlden)
-DocType: Supplier,Credit Days,Úvěrové dny
+DocType: Payment Term,Credit Days,Úvěrové dny
 apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Udělat Student Batch
 DocType: Fee Schedule,FRQ.,FRQ.
 DocType: Leave Type,Is Carry Forward,Je převádět
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +815,Get Items from BOM,Položka získaná z BOM
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,Get Items from BOM,Položka získaná z BOM
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Dodací lhůta dny
-apps/erpnext/erpnext/controllers/accounts_controller.py +556,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Řádek # {0}: Vysílání datum musí být stejné jako datum nákupu {1} aktiva {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +600,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Řádek # {0}: Vysílání datum musí být stejné jako datum nákupu {1} aktiva {2}
 DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"Zkontrolujte, zda student bydlí v Hostelu ústavu."
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,"Prosím, zadejte Prodejní objednávky v tabulce výše"
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +182,Not Submitted Salary Slips,Nepředloženo výplatních páskách
 ,Stock Summary,Sklad Souhrn
-apps/erpnext/erpnext/config/accounts.py +280,Transfer an asset from one warehouse to another,Převést aktiva z jednoho skladu do druhého
+apps/erpnext/erpnext/config/assets.py +50,Transfer an asset from one warehouse to another,Převést aktiva z jednoho skladu do druhého
 DocType: Vehicle,Petrol,Benzín
 apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Kusovník
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Řádek {0}: Typ Party Party a je nutné pro pohledávky / závazky na účtu {1}
@@ -5235,9 +5602,9 @@
 DocType: Employee Loan Application,Rate of Interest,Úroková sazba
 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 +196,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/journal_entry/journal_entry.py +194,Row {0}: Debit entry can not be linked with a {1},Row {0}: záporný nemůže být spojována s {1}
 DocType: Journal Entry,Subscription Section,Sekce odběru
-apps/erpnext/erpnext/accounts/doctype/account/account.py +193,Account {0} does not exist,Účet {0} neexistuje
+apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Account {0} does not exist,Účet {0} neexistuje
 DocType: Training Event,Training Program,Tréninkový program
 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í.
