diff --git a/erpnext/translations/cs.csv b/erpnext/translations/cs.csv
index f932925..79f2cd0 100644
--- a/erpnext/translations/cs.csv
+++ b/erpnext/translations/cs.csv
@@ -44,7 +44,7 @@
 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
 DocType: Manufacturing Settings,Overproduction Percentage For Work Order,Procento nadvýroby pro pracovní pořadí
 DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +362,Legal,Právní
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +393,Legal,Právní
 DocType: Delivery Note,Transport Receipt Date,Datum přijetí dopravy
 DocType: Shopify Settings,Sales Order Series,Série objednávek
 DocType: Vital Signs,Tongue,Jazyk
@@ -65,13 +65,13 @@
 DocType: Employee Tax Exemption Declaration,HRA as per Salary Structure,HRA podle platové struktury
 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 +197,Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1})
-apps/erpnext/erpnext/public/js/controllers/transaction.js +876,Service Stop Date cannot be before Service Start Date,Datum ukončení servisu nemůže být před datem zahájení servisu
+apps/erpnext/erpnext/public/js/controllers/transaction.js +882,Service Stop Date cannot be before Service Start Date,Datum ukončení servisu nemůže být před datem zahájení servisu
 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 +66,Show open,Ukázat otevřené
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +163,Series Updated Successfully,Řada Aktualizováno Úspěšně
 apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Odhlásit se
-apps/erpnext/erpnext/controllers/accounts_controller.py +779,{0} in row {1},{0} v řádku {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +788,{0} in row {1},{0} v řádku {1}
 DocType: Asset Finance Book,Depreciation Start Date,Datum zahájení odpisování
 DocType: Pricing Rule,Apply On,Naneste na
 DocType: Item Price,Multiple Item prices.,Více ceny položku.
@@ -82,7 +82,7 @@
 DocType: Amazon MWS Settings,Amazon MWS Settings,Amazon MWS Nastavení
 apps/erpnext/erpnext/utilities/transaction_base.py +126,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Řádek # {0}: Cena musí být stejné, jako {1}: {2} ({3} / {4})"
 ,Batch Item Expiry Status,Batch položky vypršení platnosti Stav
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +160,Bank Draft,Bank Návrh
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Bank Draft,Bank Návrh
 DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
 DocType: Mode of Payment Account,Mode of Payment Account,Způsob platby účtu
 apps/erpnext/erpnext/config/healthcare.py +8,Consultation,Konzultace
@@ -92,8 +92,7 @@
 DocType: Academic Term,Academic Term,Akademický Term
 DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,Osvobození od daně z příjmů zaměstnanců
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiál
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +71,Making website,Vytváření webových stránek
-apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +58,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
+apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +61,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of benefit application pro-rata component\
 			amount and previous claimed amount",Maximální užitek zaměstnance {0} přesahuje {1} součtem {2} částky pro-rata složky žádosti o dávku \ částka a předchozí nárokovaná částka
 DocType: Opening Invoice Creation Tool Item,Quantity,Množství
 ,Customers Without Any Sales Transactions,Zákazníci bez jakýchkoli prodejních transakcí
@@ -141,7 +140,7 @@
 DocType: Finance Book,Finance Book,Finanční kniha
 DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-
 DocType: Daily Work Summary Group,Holiday List,Seznam dovolené
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Accountant,Účetní
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Accountant,Účetní
 apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +61,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 +68,Selling Rate,Prodejní sazba
@@ -157,7 +156,7 @@
 apps/erpnext/erpnext/setup/doctype/company/company.py +50,Abbreviation cannot have more than 5 characters,Zkratka nesmí mít více než 5 znaků
 DocType: Amazon MWS Settings,AU,AU
 apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +7,Payment Request,Platba Poptávka
-apps/erpnext/erpnext/config/accounts.py +56,To view logs of Loyalty Points assigned to a Customer.,Zobrazení logů věrnostních bodů přidělených zákazníkovi.
+apps/erpnext/erpnext/config/accounts.py +556,To view logs of Loyalty Points assigned to a Customer.,Zobrazení logů věrnostních bodů přidělených zákazníkovi.
 DocType: Asset,Value After Depreciation,Hodnota po odpisech
 DocType: Student,O+,O +
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,Příbuzný
@@ -165,7 +164,7 @@
 DocType: Grading Scale,Grading Scale Name,Klasifikační stupnice Name
 apps/erpnext/erpnext/public/js/hub/marketplace.js +147,Add Users to Marketplace,Přidejte uživatele do Marketplace
 apps/erpnext/erpnext/accounts/doctype/account/account.js +37,This is a root account and cannot be edited.,To je kořen účtu a nelze upravovat.
-DocType: Sales Invoice,Company Address,adresa společnosti
+DocType: POS Profile,Company Address,adresa společnosti
 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: Subscription,Subscription Start Date,Datum zahájení předplatného
@@ -220,19 +219,19 @@
 apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Stock Reports
 DocType: Warehouse,Warehouse Detail,Sklad Detail
 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 +294,"""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"
+apps/erpnext/erpnext/stock/doctype/item/item.py +298,"""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
 DocType: Tax Rule,Tax Type,Daňové Type
 ,Completed Work Orders,Dokončené pracovní příkazy
 DocType: Support Settings,Forum Posts,Příspěvky ve fóru
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +602,Taxable Amount,Zdanitelná částka
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +603,Taxable Amount,Zdanitelná částka
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +161,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
 DocType: Leave Policy,Leave Policy Details,Zanechat podrobnosti o zásadách
 DocType: BOM,Item Image (if not slideshow),Item Image (ne-li slideshow)
 DocType: Work 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 +1136,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 +1052,Select BOM,Vybrat BOM
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1053,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/hr/doctype/holiday_list/holiday_list.py +39,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
@@ -243,7 +242,7 @@
 apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Opening,Otvor
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +36,From {0} to {1},Od {0} do {1}
 apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234,Program: ,Program:
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Nepodařilo se nastavit daně
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +51,Failed to setup taxes,Nepodařilo se nastavit daně
 DocType: Item,Copy From Item Group,Kopírovat z bodu Group
 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
@@ -281,14 +280,14 @@
 DocType: Naming Series,Prefix,Prefix
 apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html +7,Event Location,Umístění události
 DocType: Asset Settings,Asset Settings,Nastavení aktiv
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +71,Consumable,Spotřební
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +46,Consumable,Spotřební
 DocType: Student,B-,B-
 DocType: Assessment Result,Grade,Školní známka
 DocType: Restaurant Table,No of Seats,Počet sedadel
 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/setup/setup_wizard/operations/install_fixtures.py +213,Annual Salary,Roční Plat
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,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 +425,{0} {1} is frozen,{0} {1} je zmrazený
@@ -303,10 +302,10 @@
 DocType: BOM,Quality Inspection Template,Šablona inspekce kvality
 apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +136,"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 +421,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 +433,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0}
 DocType: Item,Supply Raw Materials for Purchase,Dodávky suroviny pro nákup
 DocType: Agriculture Analysis Criteria,Fertilizer,Hnojivo
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +435,"Cannot ensure delivery by Serial No as \
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +441,"Cannot ensure delivery by Serial No as \
 				Item {0} is added with and without Ensure Delivery by \
 				Serial No.","Nelze zajistit dodávku podle sériového čísla, protože je přidána položka {0} se službou Zajistit dodání podle \ sériového čísla"
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +203,At least one mode of payment is required for POS invoice.,pro POS fakturu je nutná alespoň jeden způsob platby.
@@ -320,18 +319,18 @@
 apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +39,Diff Qty,Rozdílové množství
 DocType: Production Plan,Material Request Detail,Podrobnosti o vyžádání materiálu
 DocType: Selling Settings,Default Quotation Validity Days,Výchozí dny platnosti kotací
-apps/erpnext/erpnext/controllers/accounts_controller.py +877,"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/controllers/accounts_controller.py +886,"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"
 DocType: SMS Center,SMS Center,SMS centrum
 DocType: Payroll Entry,Validate Attendance,Ověřit účast
 DocType: Sales Invoice,Change Amount,změna Částka
 DocType: Party Tax Withholding Config,Certificate Received,Certifikát byl přijat
 DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Nastavte hodnotu faktury pro B2C. B2CL a B2CS vypočítané na základě této fakturované hodnoty.
 DocType: BOM Update Tool,New BOM,Nový BOM
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +243,Prescribed Procedures,Předepsané postupy
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +307,Prescribed Procedures,Předepsané postupy
 apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Zobrazit pouze POS
 DocType: Supplier Group,Supplier Group Name,Název skupiny dodavatelů
 DocType: Driver,Driving License Categories,Kategorie řidičských oprávnění
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +125,Please enter Delivery Date,Zadejte prosím datum doručení
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +124,Please enter Delivery Date,Zadejte prosím datum doručení
 DocType: Depreciation Schedule,Make Depreciation Entry,Udělat Odpisy Entry
 DocType: Closed Document,Closed Document,Uzavřený dokument
 DocType: HR Settings,Leave Settings,Ponechte nastavení
@@ -342,9 +341,9 @@
 DocType: Payroll Period,Payroll Periods,Mzdové lhůty
 apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +18,Make Employee,Udělat zaměstnance
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Vysílání
-apps/erpnext/erpnext/config/accounts.py +351,Setup mode of POS (Online / Offline),Režim nastavení POS (Online / Offline)
+apps/erpnext/erpnext/config/accounts.py +538,Setup mode of POS (Online / Offline),Režim nastavení POS (Online / Offline)
 DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,Zakáže vytváření časových protokolů proti pracovním příkazům. Operace nesmí být sledovány proti pracovní objednávce
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +167,Execution,Provedení
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +144,Execution,Provedení
 apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Podrobnosti o prováděných operací.
 DocType: Asset Maintenance Log,Maintenance Status,Status Maintenance
 apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Podrobnosti o členství
@@ -354,7 +353,7 @@
 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: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-
 DocType: Drug Prescription,Interval,Interval
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Preference,Přednost
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +211,Preference,Přednost
 DocType: Supplier,Individual,Individuální
 DocType: Academic Term,Academics User,akademici Uživatel
 DocType: Cheque Print Template,Amount In Figure,Na obrázku výše
@@ -396,13 +395,13 @@
 DocType: Travel Itinerary,Check-out Date,Zkontrolovat datum
 DocType: Leave Type,Allow Negative Balance,Povolit záporný zůstatek
 apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Nelze odstranit typ projektu &quot;Externí&quot;
-apps/erpnext/erpnext/public/js/utils.js +254,Select Alternate Item,Vyberte alternativní položku
+apps/erpnext/erpnext/public/js/utils.js +274,Select Alternate Item,Vyberte alternativní položku
 DocType: Employee,Create User,Vytvořit uživatele
 DocType: Selling Settings,Default Territory,Výchozí Territory
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Televize
 DocType: Work Order Operation,Updated via 'Time Log',"Aktualizováno přes ""Time Log"""
 apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py +13,Select the customer or supplier.,Vyberte zákazníka nebo dodavatele.
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +448,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 +449,Advance amount cannot be greater than {0} {1},Množství předem nemůže být větší než {0} {1}
 apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +55,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}","Časový interval přeskočil, slot {0} až {1} překrýval existující slot {2} na {3}"
 DocType: Naming Series,Series List for this Transaction,Řada seznam pro tuto transakci
 DocType: Company,Enable Perpetual Inventory,Povolit trvalý inventář
@@ -432,7 +431,7 @@
 DocType: Lab Test,Custom Result,Vlastní výsledek
 DocType: Delivery Stop,Contact Name,Kontakt Jméno
 DocType: Course Assessment Criteria,Course Assessment Criteria,Hodnotící kritéria hřiště
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +31,Tax Id: ,DIČ:
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +21,Tax Id: ,DIČ:
 apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216,Student ID: ,Student ID:
 DocType: POS Customer Group,POS Customer Group,POS Customer Group
 DocType: Healthcare Practitioner,Practitioner Schedules,Pracovník plánuje
@@ -451,7 +450,7 @@
 DocType: Inpatient Record,Discharge Scheduled,Plnění je naplánováno
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +138,Relieving Date must be greater than Date of Joining,Uvolnění Datum musí být větší než Datum spojování
 DocType: POS Closing Voucher,Cashier,Pokladní
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +221,Leaves per Year,Dovolených za rok
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +198,Leaves per Year,Dovolených za rok
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +162,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Zkontrolujte ""Je Advance"" proti účtu {1}, pokud je to záloha záznam."
 apps/erpnext/erpnext/stock/utils.py +243,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
 DocType: Email Digest,Profit & Loss,Ztráta zisku
@@ -461,7 +460,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +31,Complete Job,Kompletní úloha
 DocType: Item Website Specification,Item Website Specification,Položka webových stránek Specifikace
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +543,Leave Blocked,Absence blokována
-apps/erpnext/erpnext/stock/doctype/item/item.py +814,Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti na {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +818,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 +82,Bank Entries,bankovní Příspěvky
 DocType: Customer,Is Internal Customer,Je interní zákazník
 DocType: Crop,Annual,Roční
@@ -473,7 +472,7 @@
 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 +210,People who teach at your organisation,"Lidé, kteří vyučují ve vaší organizaci"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,Software Developer,Software Developer
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Software Developer,Software Developer
 DocType: Item,Minimum Order Qty,Minimální objednávka Množství
 DocType: Supplier,Supplier Type,Dodavatel Type
 DocType: Course Scheduling Tool,Course Start Date,Začátek Samozřejmě Datum
@@ -482,10 +481,10 @@
 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 +836,Item {0} is cancelled,Položka {0} je zrušen
+apps/erpnext/erpnext/stock/doctype/item/item.py +840,Item {0} is cancelled,Položka {0} je zrušen
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +215,Depreciation Row {0}: Depreciation Start Date is entered as past date,Odpisový řádek {0}: Datum zahájení odpisování je zadáno jako poslední datum
 DocType: Contract Template,Fulfilment Terms and Conditions,Smluvní podmínky
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1137,Material Request,Požadavek na materiál
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1138,Material Request,Požadavek na materiál
 DocType: Bank Reconciliation,Update Clearance Date,Aktualizace Výprodej Datum
 ,GSTR-2,GSTR-2
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +494,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}
@@ -510,7 +509,7 @@
 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 +308,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/patches/v11_0/add_healthcare_service_unit_tree_root.py +9,All Healthcare Service Units,Všechny jednotky zdravotnických služeb
+apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py +16,All Healthcare Service Units,Všechny jednotky zdravotnických služeb
 DocType: Bank Account,Address HTML,Adresa HTML
 DocType: Lead,Mobile No.,Mobile No.
 apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html +35,Mode of Payments,Způsob platby
@@ -551,7 +550,7 @@
 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
-apps/erpnext/erpnext/projects/doctype/task/task.py +111,Circular Reference Error,Kruhové Referenční Chyba
+apps/erpnext/erpnext/projects/doctype/task/task.py +114,Circular Reference Error,Kruhové Referenční Chyba
 apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206,Student Report Card,Studentská karta
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +207,From Pin Code,Z kódu PIN
 DocType: Appointment Type,Is Inpatient,Je hospitalizován
@@ -576,7 +575,7 @@
 DocType: Volunteer,Morning,Ráno
 apps/erpnext/erpnext/accounts/utils.py +374,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."
 DocType: Program Enrollment Tool,New Student Batch,Nová studentská dávka
-apps/erpnext/erpnext/stock/doctype/item/item.py +506,{0} entered twice in Item Tax,{0} vloženo dvakrát v Daňové Položce
+apps/erpnext/erpnext/stock/doctype/item/item.py +510,{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 +121,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
@@ -589,7 +588,7 @@
 DocType: Supplier Scorecard,Scoring Standings,Hodnocení bodů
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Hodnota objednávky
 DocType: Certified Consultant,Certified Consultant,Certifikovaný konzultant
-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
+apps/erpnext/erpnext/config/accounts.py +29,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 +57,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
@@ -598,7 +597,7 @@
 DocType: Asset Value Adjustment,New Asset Value,Nová hodnota aktiv
 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 +689,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/controllers/accounts_controller.py +698,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}
 DocType: Crop Cycle,LInked Analysis,Llnked Analysis
 DocType: POS Closing Voucher,POS Closing Voucher,POS uzávěrka
 DocType: Contract,Lapsed,Zrušeno
@@ -622,7 +621,7 @@
 DocType: Purchase Order,% Received,% Přijaté
 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 +131,Credit Note Amount,Částka kreditní poznámky
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +138,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ží
@@ -671,7 +670,7 @@
 DocType: Purchase Receipt,Vehicle Date,Datum Vehicle
 DocType: Student Log,Medical,Lékařský
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +186,Reason for losing,Důvod ztráty
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1753,Please select Drug,Vyberte prosím lék
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1757,Please select Drug,Vyberte prosím lék
 apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Lead Owner cannot be same as the Lead,Olovo Majitel nemůže být stejný jako olovo
 apps/erpnext/erpnext/accounts/utils.py +380,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č
@@ -723,7 +722,7 @@
 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 +774,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 +778,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
 DocType: Amazon MWS Settings,UK,Spojené království
@@ -758,7 +757,7 @@
 DocType: Loan,Total Payment,Celková platba
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Cannot cancel transaction for Completed Work Order.,Nelze zrušit transakci pro dokončenou pracovní objednávku.
 DocType: Manufacturing Settings,Time Between Operations (in mins),Doba mezi operací (v min)
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +831,PO already created for all sales order items,PO již vytvořeno pro všechny položky prodejní objednávky
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +837,PO already created for all sales order items,PO již vytvořeno pro všechny položky prodejní objednávky
 DocType: Healthcare Service Unit,Occupied,Obsazený
 DocType: Clinical Procedure,Consumables,Spotřební materiál
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +130,{0} {1} is cancelled so the action cannot be completed,"{0} {1} je zrušena, takže akce nemůže být dokončena"
@@ -782,22 +781,22 @@
 DocType: Subscription Invoice,Subscription Invoice,Předplatné faktura
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Direct Income,Přímý příjmů
 DocType: Patient Appointment,Date TIme,Čas schůzky
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +55,"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/operations/install_fixtures.py +118,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/accounts/report/general_ledger/general_ledger.py +53,"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/operations/install_fixtures.py +93,Administrative Officer,Správní ředitel
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,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 +410,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/projects/doctype/task/task.py +50,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 +435,Please enter Warehouse for which Material Request will be raised,"Prosím, zadejte sklad, který bude materiál žádosti předložené"
 DocType: Work Order,Additional Operating Cost,Další provozní náklady
 DocType: Lab Test Template,Lab Routine,Lab Rutine
 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 +579,"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky"
+apps/erpnext/erpnext/stock/doctype/item/item.py +583,"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: Supplier,Block Supplier,Zablokujte dodavatele
 DocType: Shipping Rule,Net Weight,Hmotnost
 DocType: Job Opening,Planned number of Positions,Plánovaný počet pozic
@@ -859,7 +858,7 @@
 DocType: Healthcare Settings,Appointment Confirmation,Potvrzení jmenování
 DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-.RRRR.-
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"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 +271,Closing (Cr),Uzavření (Cr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +278,Closing (Cr),Uzavření (Cr)
 apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html +1,Hello,Ahoj
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Přemístit položku
 DocType: Employee Incentive,Incentive Amount,Část pobídky
@@ -870,11 +869,11 @@
 DocType: Budget,Ignore,Ignorovat
 apps/erpnext/erpnext/accounts/party.py +429,{0} {1} is not active,{0} {1} není aktivní
 DocType: Woocommerce Settings,Freight and Forwarding Account,Účet přepravy a zasílání
-apps/erpnext/erpnext/config/accounts.py +310,Setup cheque dimensions for printing,Zkontrolujte nastavení rozměry pro tisk
+apps/erpnext/erpnext/config/accounts.py +240,Setup cheque dimensions for printing,Zkontrolujte nastavení rozměry pro tisk
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +33,Create Salary Slips,Vytvoření platebních karet
 DocType: Vital Signs,Bloated,Nafouklý
 DocType: Salary Slip,Salary Slip Timesheet,Plat Slip časový rozvrh
-apps/erpnext/erpnext/controllers/buying_controller.py +188,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení
+apps/erpnext/erpnext/controllers/buying_controller.py +200,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení
 DocType: Item Price,Valid From,Platnost od
 DocType: Sales Invoice,Total Commission,Celkem Komise
 DocType: Tax Withholding Account,Tax Withholding Account,Účet pro zadržení daně
@@ -883,11 +882,11 @@
 DocType: Buying Settings,Purchase Receipt Required,Příjmka je vyžadována
 DocType: Delivery Note,Rail,Železnice
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +267,Target warehouse in row {0} must be same as Work Order,Cílový sklad v řádku {0} musí být stejný jako pracovní objednávka
-apps/erpnext/erpnext/stock/doctype/item/item.py +179,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 +183,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 +143,No records found in the Invoice table,Nalezené v tabulce faktury Žádné záznamy
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +36,Please select Company and Party Type first,Vyberte první společnost a Party Typ
 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 +331,Financial / accounting year.,Finanční / Účetní rok.
+apps/erpnext/erpnext/config/accounts.py +261,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 +166,"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit"
 DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,Zákaznická skupina nastaví vybranou skupinu při synchronizaci zákazníků se službou Shopify
@@ -936,9 +935,9 @@
 DocType: Authorization Rule,Customer or Item,Zákazník nebo položka
 apps/erpnext/erpnext/config/selling.py +28,Customer database.,Databáze zákazníků.
 DocType: Quotation,Quotation To,Nabídka k
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +305,Middle Income,Středními příjmy
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +243,Opening (Cr),Otvor (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +946,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/setup/setup_wizard/operations/install_fixtures.py +215,Middle Income,Středními příjmy
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +250,Opening (Cr),Otvor (Cr)
+apps/erpnext/erpnext/stock/doctype/item/item.py +950,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 +378,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: Share Balance,Share Balance,Sázení podílů
@@ -957,9 +956,9 @@
 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/accounts/doctype/purchase_invoice/purchase_invoice.js +712,An error occurred during the update process,Během procesu aktualizace došlo k chybě
 DocType: Restaurant Reservation,Restaurant Reservation,Rezervace restaurace
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +166,Proposal Writing,Návrh Psaní
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,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/setup/setup_wizard/setup_wizard.py +15,Wrapping up,Obalte se
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Notify Customers via Email,Informujte zákazníky e-mailem
 DocType: Item,Batch Number Series,Číselná řada šarží
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +54,Another Sales Person {0} exists with the same Employee id,Další prodeje osoba {0} existuje se stejným id zaměstnance
@@ -971,7 +970,7 @@
 apps/erpnext/erpnext/config/education.py +180,Masters,Masters
 DocType: Employee Onboarding,Employee Onboarding Template,Šablona zaměstnanců na palubě
 DocType: Assessment Plan,Maximum Assessment Score,Maximální skóre Assessment
-apps/erpnext/erpnext/config/accounts.py +161,Update Bank Transaction Dates,Transakční Data aktualizace Bank
+apps/erpnext/erpnext/config/accounts.py +134,Update Bank Transaction Dates,Transakční Data aktualizace Bank
 apps/erpnext/erpnext/config/projects.py +41,Time Tracking,Time Tracking
 DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLIKÁT PRO TRANSPORTER
 apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +57,Row {0}# Paid Amount cannot be greater than requested advance amount,Řádek {0} # Placená částka nesmí být vyšší než požadovaná částka
@@ -1008,7 +1007,7 @@
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +83,Net Change in Inventory,Čistá Změna stavu zásob
 DocType: Employee,Passport Number,Číslo pasu
 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 +112,Manager,Manažer
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +87,Manager,Manažer
 DocType: Payment Entry,Payment From / To,Platba z / do
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +8,From Fiscal Year,Od fiskálního roku
 apps/erpnext/erpnext/selling/doctype/customer/customer.py +185,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}
@@ -1052,15 +1051,15 @@
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{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 +254,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 +257,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/manufacturing/doctype/job_card/job_card.js +14,Material Transfer,Přesun materiálu
 DocType: Cost Center,Cost Center Number,Číslo nákladového střediska
 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 +236,Opening (Dr),Opening (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +243,Opening (Dr),Opening (Dr)
 DocType: Compensatory Leave Request,Work End Date,Datum ukončení práce
 DocType: Loan,Applicant,Žadatel
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +37,Posting timestamp must be after {0},Časová značka zadání musí být po {0}
-apps/erpnext/erpnext/config/accounts.py +44,To make recurring documents,Provádět opakované dokumenty
+apps/erpnext/erpnext/config/accounts.py +293,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: Loan,Total Interest Payable,Celkem splatných úroků
@@ -1088,7 +1087,7 @@
 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: Sales Invoice,Port Code,Port Code
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1030,Reserve Warehouse,Rezervní sklad
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1031,Reserve Warehouse,Rezervní sklad
 DocType: Lead,Lead is an Organization,Vedoucí je organizace
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Předprodej
 DocType: Instructor Log,Other Details,Další podrobnosti
@@ -1099,12 +1098,12 @@
 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/operations/install_fixtures.py +351,Marketing,Marketing
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +382,Marketing,Marketing
 DocType: Sales Invoice,Redeem Loyalty Points,Uplatnit věrnostní body
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +348,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 +672,Row #{0}: Asset {1} does not linked to Item {2},Řádek # {0}: Asset {1} není spojena s item {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +681,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 +408,Preview Salary Slip,Preview výplatní pásce
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +64,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í
@@ -1119,7 +1118,7 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +189,From Address 1,Z adresy 1
 DocType: Email Digest,Next email will be sent on:,Další e-mail bude odeslán dne:
 DocType: Supplier Scorecard,Per Week,Za týden
-apps/erpnext/erpnext/stock/doctype/item/item.py +721,Item has variants.,Položka má varianty.
+apps/erpnext/erpnext/stock/doctype/item/item.py +725,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
@@ -1137,7 +1136,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Aerospace
 ,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
 DocType: Journal Entry,Credit Card Entry,Vstup Kreditní karta
-apps/erpnext/erpnext/config/accounts.py +74,Company and Accounts,Společnost a účty
+apps/erpnext/erpnext/config/accounts.py +35,Company and Accounts,Společnost a účty
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +85,In Value,v Hodnota
 DocType: Asset Settings,Depreciation Options,Možnosti odpisů
 apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Either location or employee must be required,Musí být požadováno umístění nebo zaměstnanec
@@ -1158,7 +1157,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,{0} is not a stock Item,{0} není skladová položka
 apps/erpnext/erpnext/hr/notification/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 +298,Please select Sample Retention Warehouse in Stock Settings first,Zvolte prosím nejprve Sample Retention Warehouse in Stock Stock
+apps/erpnext/erpnext/stock/doctype/item/item.py +302,Please select Sample Retention Warehouse in Stock Settings first,Zvolte prosím nejprve Sample Retention Warehouse in Stock Stock
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +62,Please select the Multiple Tier Program type for more than one collection rules.,Zvolte typ víceúrovňového programu pro více než jednu pravidla kolekce.
 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
@@ -1187,7 +1186,7 @@
 DocType: BOM,Website Specifications,Webových stránek Specifikace
 DocType: Special Test Items,Particulars,Podrobnosti
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +23,{0}: From {0} of type {1},{0}: Od {0} typu {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +387,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
+apps/erpnext/erpnext/controllers/buying_controller.py +399,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 +353,"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}"
 DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,Účet z přecenění směnného kurzu
@@ -1197,7 +1196,7 @@
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Get from Patient Encounter,Získejte z setkání pacienta
 DocType: Subscriber,Subscriber,Odběratel
 DocType: Item Attribute Value,Item Attribute Value,Položka Hodnota atributu
-apps/erpnext/erpnext/projects/doctype/project/project.py +472,Please Update your Project Status,Aktualizujte stav projektu
+apps/erpnext/erpnext/projects/doctype/project/project.py +455,Please Update your Project Status,Aktualizujte stav projektu
 apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +26,Currency Exchange must be applicable for Buying or for Selling.,Směnárna musí být platná pro nákup nebo pro prodej.
 DocType: Item,Maximum sample quantity that can be retained,"Maximální množství vzorku, které lze zadržet"
 DocType: Project Update,How is the Project Progressing Right Now?,Jak probíhá projekt právě teď?
@@ -1269,7 +1268,7 @@
 DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,Aktualizovat cenu z Shopify do ERPNext Ceník
 apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Nastavení e-mailový účet
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,"Prosím, nejdřív zadejte položku"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +316,Needs Analysis,Analýza potřeb
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +221,Needs Analysis,Analýza potřeb
 DocType: Asset Repair,Downtime,Nefunkčnost
 DocType: Account,Liability,Odpovědnost
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +228,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}.
@@ -1280,20 +1279,20 @@
 apps/erpnext/erpnext/stock/get_item_details.py +523,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 +253,Warning: Invalid Attachment {0},Varování: Neplatná Příloha {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +257,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 +810,No Permission,Nemáte oprávnění
 DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,Kontrolní seznam plnění smlouvy
 DocType: Vital Signs,Heart Rate / Pulse,Srdeční frekvence / puls
 DocType: Company,Default Bank Account,Výchozí Bankovní účet
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +78,"To filter based on Party, select Party Type first","Chcete-li filtrovat na základě Party, vyberte typ Party první"
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +76,"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 +46,'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 +146,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/inpatient_record/inpatient_record_dashboard.py +12,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 +676,Row #{0}: Asset {1} must be submitted,Řádek # {0}: {1} Asset musí být předloženy
+apps/erpnext/erpnext/controllers/accounts_controller.py +685,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: Item,If subcontracted to a vendor,Pokud se subdodávky na dodavatele
 apps/erpnext/erpnext/education/doctype/student_group/student_group.js +113,Student Group is already updated.,Studentská skupina je již aktualizována.
@@ -1319,7 +1318,7 @@
 DocType: Asset,Opening Accumulated Depreciation,Otevření Oprávky
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +50,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 +373,C-Form records,C-Form záznamy
+apps/erpnext/erpnext/config/accounts.py +298,C-Form records,C-Form záznamy
 apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +74,The shares already exist,Akcie již existují
 apps/erpnext/erpnext/config/selling.py +322,Customer and Supplier,Zákazník a Dodavatel
 DocType: Email Digest,Email Digest Settings,Nastavení e-mailu Digest
@@ -1377,7 +1376,7 @@
 DocType: Payroll Entry,Bimonthly,dvouměsíčník
 DocType: Vehicle Service,Brake Pad,Brzdový pedál
 DocType: Fertilizer,Fertilizer Contents,Obsah hnojiv
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +361,Research & Development,Výzkum a vývoj
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +392,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ý
@@ -1429,7 +1428,7 @@
 DocType: Examination Result,Examination Result,vyšetření Výsledek
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +928,Purchase Receipt,Příjemka
 ,Received Items To Be Billed,"Přijaté položek, které mají být účtovány"
-apps/erpnext/erpnext/config/accounts.py +341,Currency exchange rate master.,Devizový kurz master.
+apps/erpnext/erpnext/config/accounts.py +271,Currency exchange rate master.,Devizový kurz master.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +210,Reference Doctype must be one of {0},Referenční Doctype musí být jedním z {0}
 apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,Filtr Celkový počet nula
 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}
@@ -1440,7 +1439,7 @@
 DocType: Employee Boarding Activity,Activity Name,Název aktivity
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +867,Change Release Date,Změnit datum vydání
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +218,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,Množství hotového produktu <b>{0}</b> a Pro množství <b>{1}</b> se nemohou lišit
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +258,Closing (Opening + Total),Uzavření (otevření + celkem)
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +256,Closing (Opening + Total),Uzavření (otevření + celkem)
 DocType: Delivery Settings,Dispatch Notification Attachment,Oznámení o odeslání
 DocType: Payroll Entry,Number Of Employees,Počet zaměstnanců
 DocType: Journal Entry,Depreciation Entry,odpisy Entry
@@ -1452,7 +1451,7 @@
 DocType: Purchase Receipt Item Supplied,Required Qty,Požadované množství
 DocType: Marketplace Settings,Custom Data,Vlastní data
 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.
-apps/erpnext/erpnext/controllers/buying_controller.py +570,Serial no is mandatory for the item {0},Sériové číslo je povinné pro položku {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +582,Serial no is mandatory for the item {0},Sériové číslo je povinné pro položku {0}
 DocType: Bank Reconciliation,Total Amount,Celková částka
 apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py +24,From Date and To Date lie in different Fiscal Year,Od data a do data leží v různých fiskálních letech
 apps/erpnext/erpnext/healthcare/utils.py +160,The Patient {0} do not have customer refrence to invoice,Pacient {0} nemá fakturu zákazníka
@@ -1479,19 +1478,19 @@
 DocType: Support Search Source,Search Term Param Name,Hledaný výraz Param Name
 DocType: Item Barcode,Item Barcode,Položka Barcode
 DocType: Woocommerce Settings,Endpoints,Koncové body
-apps/erpnext/erpnext/stock/doctype/item/item.py +716,Item Variants {0} updated,Bod Varianty {0} aktualizováno
+apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item Variants {0} updated,Bod Varianty {0} aktualizováno
 DocType: Quality Inspection Reading,Reading 6,Čtení 6
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +994,Cannot {0} {1} {2} without any negative outstanding invoice,Nelze {0} {1} {2} bez negativních vynikající faktura
 DocType: Share Transfer,From Folio No,Z folia č
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Záloha přijaté faktury
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +231,Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
-apps/erpnext/erpnext/config/accounts.py +284,Define budget for a financial year.,Definovat rozpočet pro finanční rok.
+apps/erpnext/erpnext/config/accounts.py +214,Define budget for a financial year.,Definovat rozpočet pro finanční rok.
 DocType: Shopify Tax Account,ERPNext Account,ERPN další účet
-apps/erpnext/erpnext/controllers/accounts_controller.py +57,{0} is blocked so this transaction cannot proceed,"{0} je zablokována, aby tato transakce nemohla pokračovat"
+apps/erpnext/erpnext/controllers/accounts_controller.py +58,{0} is blocked so this transaction cannot proceed,"{0} je zablokována, aby tato transakce nemohla pokračovat"
 DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,Akce při překročení akumulovaného měsíčního rozpočtu na MR
 DocType: Employee,Permanent Address Is,Trvalé bydliště je
 DocType: Work Order Operation,Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +128,Healthcare Practitioner {0} not available on {1},Lékařský lékař {0} není dostupný v {1}
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +130,Healthcare Practitioner {0} not available on {1},Lékařský lékař {0} není dostupný v {1}
 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 Tax Exemption Proof Submission,Rented To Date,Pronajato k datu
@@ -1572,13 +1571,13 @@
 DocType: Expense Claim,Total Advance Amount,Celková výše zálohy
 DocType: Delivery Stop,Estimated Arrival,odhadovaný příjezd
 apps/erpnext/erpnext/templates/pages/help.html +29,See All Articles,Zobrazit všechny články
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Walk In,Vejít
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +165,Walk In,Vejít
 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 +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/setup/setup_wizard/operations/install_fixtures.py +183,White,Bílá
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +160,White,Bílá
 DocType: SMS Center,All Lead (Open),Všechny Lead (Otevřeny)
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +352,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/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,Ze seznamu zaškrtávacích políček můžete vybrat pouze jednu možnost.
@@ -1590,7 +1589,7 @@
 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 +139,Order Type must be one of {0},Typ objednávky musí být jedním z {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +142,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í
@@ -1601,7 +1600,7 @@
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +132,Added to details,Přidáno do podrobností
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,rozvrh
 DocType: Budget,Applicable on Material Request,Použitelné na žádosti o materiál
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +217,Stock Options,Akciové opce
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +194,Stock Options,Akciové opce
 apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +628,No Items added to cart,Do košíku nejsou přidány žádné položky
 DocType: Journal Entry Account,Expense Claim,Hrazení nákladů
 apps/erpnext/erpnext/assets/doctype/asset/asset.js +352,Do you really want to restore this scrapped asset?,Opravdu chcete obnovit tento vyřazen aktivum?
@@ -1631,7 +1630,7 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js +471,Variant creation has been queued.,Tvorba variantu byla zařazena do fronty.
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100,Work Summary for {0},Souhrn práce pro {0}
 DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,Prvním schvalovacím přístupem v seznamu bude nastaven výchozí přístup.
-apps/erpnext/erpnext/stock/doctype/item/item.py +770,Attribute table is mandatory,Atribut tabulka je povinné
+apps/erpnext/erpnext/stock/doctype/item/item.py +774,Attribute table is mandatory,Atribut tabulka je povinné
 DocType: Production Plan,Get Sales Orders,Získat Prodejní objednávky
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +69,{0} can not be negative,{0} nemůže být negativní
 apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js +37,Connect to Quickbooks,Připojte k Quickbookům
@@ -1650,7 +1649,7 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +187,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 +893,Please select a field to edit from numpad,"Vyberte pole, které chcete upravit z čísla"
-apps/erpnext/erpnext/stock/doctype/item/item.py +289,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/stock/doctype/item/item.py +293,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í."
 DocType: Subscription Plan,Fixed rate,Fixní sazba
 apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js +7,Admit,Připustit
 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
@@ -1700,7 +1699,7 @@
 DocType: Buying Settings,Material Transferred for Subcontract,Materiál převedený na subdodávky
 DocType: Email Digest,Purchase Orders Items Overdue,Položky nákupních příkazů po splatnosti
 apps/erpnext/erpnext/accounts/page/pos/pos.js +1638,ZIP Code,PSČ
-apps/erpnext/erpnext/controllers/selling_controller.py +262,Sales Order {0} is {1},Prodejní objednávky {0} {1}
+apps/erpnext/erpnext/controllers/selling_controller.py +265,Sales Order {0} is {1},Prodejní objednávky {0} {1}
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +260,Select interest income account in loan {0},Vyberte účet úrokového výnosu v úvěru {0}
 DocType: Opportunity,Contact Info,Kontaktní informace
 apps/erpnext/erpnext/config/stock.py +322,Making Stock Entries,Tvorba přírůstků zásob
@@ -1716,7 +1715,7 @@
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +380,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 +28,To {0} | {1} {2},Chcete-li {0} | {1} {2}
+apps/erpnext/erpnext/controllers/selling_controller.py +29,To {0} | {1} {2},Chcete-li {0} | {1} {2}
 apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js +13,This is a root supplier group and cannot be edited.,Toto je kořenová skupina dodavatelů a nemůže být editována.
 DocType: Delivery Note,Driver Name,Jméno řidiče
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Average Age,Průměrný věk
@@ -1729,11 +1728,11 @@
 DocType: Company,Parent Company,Mateřská společnost
 apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Hotel Pokoje typu {0} nejsou k dispozici v {1}
 DocType: Healthcare Practitioner,Default Currency,Výchozí měna
-apps/erpnext/erpnext/controllers/selling_controller.py +147,Maximum discount for Item {0} is {1}%,Maximální sleva pro položku {0} je {1}%
+apps/erpnext/erpnext/controllers/selling_controller.py +150,Maximum discount for Item {0} is {1}%,Maximální sleva pro položku {0} je {1}%
 DocType: Asset Movement,From Employee,Od Zaměstnance
 DocType: Driver,Cellphone Number,Mobilní číslo
 DocType: Project,Monitor Progress,Monitorování pokroku
-apps/erpnext/erpnext/controllers/accounts_controller.py +536,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornění: Systém nebude kontrolovat nadfakturace, protože částka za položku na {1} je nula {0}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +545,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: Supplier Quotation,Auto Repeat Section,Sekce automatického opakování
 DocType: Upload Attendance,Attendance From Date,Účast Datum od
@@ -1743,13 +1742,13 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +241,{0} {1} must be submitted,{0} {1} musí být odeslaný
 DocType: Buying Settings,Default Supplier Group,Výchozí skupina dodavatelů
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,Quantity must be less than or equal to {0},Množství musí být menší než nebo rovno {0}
-apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +42,Maximum amount eligible for the component {0} exceeds {1},Maximální částka způsobilá pro komponentu {0} přesahuje {1}
+apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +44,Maximum amount eligible for the component {0} exceeds {1},Maximální částka způsobilá pro komponentu {0} přesahuje {1}
 DocType: Department Approver,Department Approver,Schválení oddělení
 DocType: QuickBooks Migrator,Application Settings,Nastavení aplikace
 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 +192,Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +204,Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
 apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +22,There isn't any item variant for the selected item,Pro zvolenou položku není k dispozici žádná varianta položky
 DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detail
 DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Platba Odsouhlasení faktury
@@ -1759,7 +1758,7 @@
 ,HSN-wise-summary of outward supplies,HSN - shrnutí vnějších dodávek
 DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registrace firmy čísla pro váš odkaz. Daňové čísla atd
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +261,To State,Do stavu
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +145,Distributor,Distributor
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +122,Distributor,Distributor
 DocType: Asset Finance Book,Asset Finance Book,Finanční kniha majetku
 DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Nákupní košík Shipping Rule
 apps/erpnext/erpnext/public/js/controllers/transaction.js +72,Please set 'Apply Additional Discount On',Prosím nastavte na &quot;Použít dodatečnou slevu On&quot;
@@ -1772,7 +1771,7 @@
 DocType: Setup Progress Action,Action Name,Název akce
 apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +17,Start Year,Začátek Rok
 apps/erpnext/erpnext/regional/india/utils.py +28,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}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +81,PDC/LC,PDC / LC
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +84,PDC/LC,PDC / LC
 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
 DocType: Payment Request,Outward,Vnější
@@ -1794,8 +1793,8 @@
 DocType: Amazon MWS Settings,CN,CN
 DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Pole budou kopírovány pouze v době vytváření.
 DocType: Setup Progress Action,Domains,Domény
-apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date',"""Skutečné datum zahájení"" nemůže být větší než ""Skutečné datum ukončení"""
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +359,Management,Řízení
+apps/erpnext/erpnext/projects/doctype/task/task.py +44,'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/operations/install_fixtures.py +390,Management,Řízení
 DocType: Cheque Print Template,Payer Settings,Nastavení plátce
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +651,No pending Material Requests found to link for the given items.,Žádná nevyřízená žádost o materiál nebyla nalezena k odkazu na dané položky.
 apps/erpnext/erpnext/public/js/utils/party.js +193,Select company first,Nejprve vyberte společnost
@@ -1833,12 +1832,12 @@
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Skladovou pohyb {0} vytvořil
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py +110,You don't have enought Loyalty Points to redeem,Nemáte dostatečné věrnostní body k uplatnění
 apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py +23,Please set associated account in Tax Withholding Category {0} against Company {1},Nastavte přidružený účet v kategorii odmítnutí daní {0} proti společnosti {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +393,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/controllers/buying_controller.py +405,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/item/item.js +203,Changing Customer Group for the selected Customer is not allowed.,Změna skupiny zákazníků pro vybraného zákazníka není povolena.
 ,Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +77,Updating estimated arrival times.,Aktualizace odhadovaných časů příjezdu.
 DocType: Program Enrollment Tool,Enrollment Details,Podrobnosti o zápisu
-apps/erpnext/erpnext/stock/doctype/item/item.py +680,Cannot set multiple Item Defaults for a company.,Nelze nastavit více položek Výchozí pro společnost.
+apps/erpnext/erpnext/stock/doctype/item/item.py +684,Cannot set multiple Item Defaults for a company.,Nelze nastavit více položek Výchozí pro společnost.
 DocType: Purchase Invoice Item,Net Rate,Čistá míra
 apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +194,Please select a customer,Vyberte zákazníka
 DocType: Leave Policy,Leave Allocations,Ponechat alokace
@@ -1879,7 +1878,7 @@
 DocType: Subscription Settings,Subscription Settings,Nastavení předplatného
 DocType: Purchase Invoice,Update Auto Repeat Reference,Aktualizovat referenci automatického opakování
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +273,Optional Holiday List not set for leave period {0},Volitelný prázdninový seznam není nastaven na období dovolené {0}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +165,Research,Výzkum
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +142,Research,Výzkum
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +243,To Address 2,Na adresu 2
 DocType: Maintenance Visit Purpose,Work Done,Odvedenou práci
 apps/erpnext/erpnext/controllers/item_variant.py +35,Please specify at least one attribute in the Attributes table,Uveďte prosím alespoň jeden atribut v tabulce atributy
@@ -1890,16 +1889,16 @@
 DocType: Bank Statement Transaction Entry,Reconciled Transactions,Zkombinované transakce
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +42,Earliest,Nejstarší
 DocType: Crop Cycle,Linked Location,Linked Location
-apps/erpnext/erpnext/stock/doctype/item/item.py +553,"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/stock/doctype/item/item.py +557,"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 +106,Rest Of The World,Zbytek světa
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.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
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1638,Get Items from Healthcare Services,Získejte položky od zdravotnických služeb
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1642,Get Items from Healthcare Services,Získejte položky od zdravotnických služeb
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Activity Type is mandatory.,Řádek {0}: typ činnosti je povinná.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +176,Dividends Paid,Dividendy placené
 apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +39,Accounting Ledger,Účetní Statistika
@@ -1936,7 +1935,7 @@
 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/stock/doctype/material_request/material_request.js +1046,For Default Supplier (optional),Výchozí dodavatel (volitelné)
 DocType: Supplier Quotation Item,Lead Time in days,Čas leadu ve dnech
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +82,Accounts Payable Summary,Splatné účty Shrnutí
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +83,Accounts Payable Summary,Splatné účty Shrnutí
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +214,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 +84,Sales Order {0} is not valid,Prodejní objednávky {0} není platný
@@ -1945,7 +1944,7 @@
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +146,Lab Test Prescriptions,Předpisy pro laboratorní testy
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +164,"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/operations/install_fixtures.py +172,Small,Malý
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +149,Small,Malý
 DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order","Pokud služba Shopify neobsahuje zákazníka v objednávce, pak při synchronizaci objednávek systém bude považovat výchozí zákazníka za objednávku"
 DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Otevření položky nástroje pro vytváření faktur
 DocType: Cashier Closing Payments,Cashier Closing Payments,Pokladní hotovostní platby
@@ -1975,13 +1974,13 @@
 apps/erpnext/erpnext/accounts/page/pos/pos.js +801,Sync Master Data,Sync Master Data
 DocType: Asset Repair,Repair Cost,náklady na opravu
 apps/erpnext/erpnext/utilities/user_progress.py +138,Your Products or Services,Vaše Produkty nebo Služby
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Přihlášení selhalo
-apps/erpnext/erpnext/controllers/buying_controller.py +617,Asset {0} created,Asset {0} vytvořen
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +16,Failed to login,Přihlášení selhalo
+apps/erpnext/erpnext/controllers/buying_controller.py +629,Asset {0} created,Asset {0} vytvořen
 DocType: Special Test Items,Special Test Items,Speciální zkušební položky
 apps/erpnext/erpnext/public/js/hub/marketplace.js +101,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,"Musíte být uživatelem s rolí Správce systému a Správce položek, který se má zaregistrovat na webu Marketplace."
 DocType: Bank Statement Transaction Payment Item,Mode of Payment,Způsob platby
 apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +25,As per your assigned Salary Structure you cannot apply for benefits,Podle vaší přiřazené struktury platu nemůžete žádat o výhody
-apps/erpnext/erpnext/stock/doctype/item/item.py +227,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 +231,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: Purchase Invoice Item,BOM,BOM
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +71,This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.
 apps/erpnext/erpnext/accounts/doctype/account/account.js +133,Merge,Spojit
@@ -1990,7 +1989,7 @@
 DocType: Warehouse,Warehouse Contact Info,Sklad Kontaktní informace
 DocType: Payment Entry,Write Off Difference Amount,Odepsat Difference Částka
 DocType: Volunteer,Volunteer Name,Jméno dobrovolníka
-apps/erpnext/erpnext/controllers/accounts_controller.py +784,Rows with duplicate due dates in other rows were found: {0},Řádky s duplicitními daty v jiných řádcích byly nalezeny: {0}
+apps/erpnext/erpnext/controllers/accounts_controller.py +793,Rows with duplicate due dates in other rows were found: {0},Řádky s duplicitními daty v jiných řádcích byly nalezeny: {0}
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +535,"{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/hr/doctype/leave_encashment/leave_encashment.py +55,No Salary Structure assigned for Employee {0} on given date {1},Žádná struktura výdělku pro zaměstnance {0} v daný den {1}
 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}
@@ -2008,7 +2007,7 @@
 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/work_order/work_order.js +372,Please set the Item Code first,Nejprve nastavte kód položky
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +157,Doc Type,Doc Type
-apps/erpnext/erpnext/controllers/selling_controller.py +132,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 +135,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
 DocType: Subscription Plan,Billing Interval Count,Počet fakturačních intervalů
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py +10,Appointments and Patient Encounters,Setkání a setkání s pacienty
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +135,Value missing,Hodnota chybí
@@ -2064,11 +2063,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/operations/install_fixtures.py +143,Hardware,Technické vybavení
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Hardware,Technické vybavení
 DocType: Prescription Dosage,Prescription Dosage,Dávkování na předpis
 DocType: Contract,HR Manager,HR Manager
 apps/erpnext/erpnext/accounts/party.py +196,Please select a Company,Vyberte společnost
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +95,Privilege Leave,Privilege Leave
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +70,Privilege Leave,Privilege Leave
 DocType: Purchase Invoice,Supplier Invoice Date,Dodavatelské faktury Datum
 DocType: Asset Settings,This value is used for pro-rata temporis calculation,Tato hodnota se používá pro výpočet pro-rata temporis
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +91,You need to enable Shopping Cart,Musíte povolit Nákupní košík
@@ -2088,7 +2087,7 @@
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +188,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 +341,Food,Jídlo
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +69,Ageing Range 3,Stárnutí Rozsah 3
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +42,Ageing Range 3,Stárnutí Rozsah 3
 DocType: POS Closing Voucher Details,POS Closing Voucher Details,Podrobnosti závěrečného poukazu POS
 DocType: Shopify Log,Shopify Log,Shopify Přihlásit
 DocType: Inpatient Occupancy,Check In,Check In
@@ -2117,7 +2116,7 @@
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +104,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
 DocType: Payment Request,Transaction Currency,Transakční měna
-apps/erpnext/erpnext/controllers/buying_controller.py +33,From {0} | {1} {2},Od {0} | {1} {2}
+apps/erpnext/erpnext/controllers/buying_controller.py +34,From {0} | {1} {2},Od {0} | {1} {2}
 apps/erpnext/erpnext/public/js/hub/marketplace.js +163,Some emails are invalid,Některé e-maily jsou neplatné
 DocType: Work Order Operation,Operation Description,Operace Popis
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Nelze měnit Fiskální rok Datum zahájení a fiskální rok datum ukončení, jakmile fiskální rok se uloží."
@@ -2129,7 +2128,7 @@
 DocType: Healthcare Practitioner,Contacts and Address,Kontakty a adresa
 DocType: Salary Structure,Max Benefits (Amount),Maximální výhody (částka)
 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í"""
+apps/erpnext/erpnext/projects/doctype/task/task.py +41,'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í"""
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +107,No data for this period,Pro toto období nejsou k dispozici žádná data
 DocType: Course Scheduling Tool,Course End Date,Konec Samozřejmě Datum
 DocType: Holiday List,Holidays,Prázdniny
@@ -2142,7 +2141,7 @@
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +92,Net Change in Fixed Asset,Čistá změna ve stálých aktiv
 apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py +38,Reqd Qty,Požadovaný počet
 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 +883,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/controllers/accounts_controller.py +892,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Obvinění z typu ""Aktuální"" v řádku {0} nemůže být zařazena do položky Rate"
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +531,Max: {0},Max: {0}
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Od datetime
 DocType: Shopify Settings,For Company,Pro Společnost
@@ -2157,7 +2156,7 @@
 DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,První Průvodce výdajů v seznamu bude nastaven jako výchozí schvalovatel výdajů.
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +611,cannot be greater than 100,nemůže být větší než 100
 apps/erpnext/erpnext/public/js/hub/marketplace.js +96,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,"Musíte být jiným uživatelem než správcem s rolí Správce systému a Správce položek, který se má zaregistrovat na webu Marketplace."
-apps/erpnext/erpnext/stock/doctype/item/item.py +826,Item {0} is not a stock Item,Položka {0} není skladem
+apps/erpnext/erpnext/stock/doctype/item/item.py +830,Item {0} is not a stock Item,Položka {0} není skladem
 DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-
 DocType: Maintenance Visit,Unscheduled,Neplánovaná
 DocType: Employee,Owned,Vlastník
@@ -2185,10 +2184,10 @@
 DocType: HR Settings,Employee Settings,Nastavení zaměstnanců
 apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html +13,Loading Payment System,Načítání platebního systému
 ,Batch-Wise Balance History,Batch-Wise Balance History
-apps/erpnext/erpnext/controllers/accounts_controller.py +1071,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,"Řádek # {0}: Nelze nastavit hodnotu, pokud je částka vyšší než částka fakturovaná pro položku {1}."
+apps/erpnext/erpnext/controllers/accounts_controller.py +1122,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,"Řádek # {0}: Nelze nastavit hodnotu, pokud je částka vyšší než částka fakturovaná pro položku {1}."
 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/operations/install_fixtures.py +108,Apprentice,Učeň
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +83,Apprentice,Učeň
 DocType: Purchase Invoice,Company GSTIN,Společnost GSTIN
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +106,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.
@@ -2202,7 +2201,7 @@
 DocType: HR Settings,Leave Approver Mandatory In Leave Application,Povolení odchody je povinné v aplikaci Nechat
 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 +206,Tax Rule for transactions.,Daňové Pravidlo pro transakce.
+apps/erpnext/erpnext/config/accounts.py +179,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 vyžadován oproti účtu pohledávek {2}
 DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Celkem Daně a poplatky (Company Měnové)
@@ -2222,7 +2221,7 @@
 DocType: Stock Entry,Total Additional Costs,Celkem Dodatečné náklady
 apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +47,No of Interactions,Počet interakcí
 DocType: BOM,Scrap Material Cost(Company Currency),Šrot materiálové náklady (Company měna)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +69,Sub Assemblies,Podsestavy
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +44,Sub Assemblies,Podsestavy
 DocType: Asset,Asset Name,Asset Name
 DocType: Project,Task Weight,úkol Hmotnost
 DocType: Shipping Rule Condition,To Value,Chcete-li hodnota
@@ -2240,7 +2239,7 @@
 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/operations/install_fixtures.py +113,Analyst,Analytik
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Analyst,Analytik
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +20,{0} is not in a valid Payroll Period,{0} není v platném mzdovém období
 DocType: Employee Benefit Application,Max Benefits (Yearly),Maximální přínosy (ročně)
 DocType: Item,Inventory,Inventář
@@ -2252,7 +2251,7 @@
 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/operations/install_fixtures.py +135,Government,Vláda
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +112,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
 DocType: Asset Movement,Source Location,Umístění zdroje
 apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Jméno Institute
@@ -2269,7 +2268,7 @@
 DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,Importovat doručovací poznámky z Shopify při odeslání
 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 +286,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 +290,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 +146,No records found in the Payment table,Nalezené v tabulce platby Žádné záznamy
 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}
@@ -2290,7 +2289,7 @@
 DocType: Pricing Rule,For Price List,Pro Ceník
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Executive Search
 DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.YYYY.-
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Nastavení výchozích hodnot
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +56,Setting defaults,Nastavení výchozích hodnot
 DocType: Loyalty Program,Auto Opt In (For all customers),Automatická registrace (pro všechny zákazníky)
 apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,vytvoření vede
 DocType: Maintenance Schedule,Schedules,Plány
@@ -2319,7 +2318,7 @@
 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/healthcare/doctype/lab_test/lab_test.js +194,Please input all required Result Value(s),Zadejte prosím všechny požadované hodnoty výsledků
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +119,Accounts Receivable Summary,Pohledávky Shrnutí
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +137,Accounts Receivable Summary,Pohledávky Shrnutí
 DocType: POS Closing Voucher,Linked Invoices,Linkované faktury
 DocType: Loan,Monthly Repayment Amount,Výše měsíční splátky
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Otevření faktur
@@ -2353,7 +2352,7 @@
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +72,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 +31,Healthcare (beta),Zdravotnictví (beta)
 DocType: Production Plan Sales Order,Production Plan Sales Order,Výrobní program prodejní objednávky
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +427,"No active BOM found for item {0}. Delivery by \
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +433,"No active BOM found for item {0}. Delivery by \
 						Serial No cannot be ensured",Pro položku {0} nebyl nalezen žádný aktivní kusovníček. Dodání pomocí \ sériového čísla nemůže být zajištěno
 DocType: Sales Partner,Sales Partner Target,Sales Partner Target
 DocType: Loan Type,Maximum Loan Amount,Maximální výše úvěru
@@ -2369,7 +2368,7 @@
 ,Lead Name,Jméno leadu
 ,POS,POS
 DocType: C-Form,III,III
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +314,Prospecting,Prospektování
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +219,Prospecting,Prospektování
 apps/erpnext/erpnext/config/stock.py +317,Opening Stock Balance,Počáteční cena zásob
 DocType: Asset Category Account,Capital Work In Progress Account,Pokročilý účet kapitálové práce
 apps/erpnext/erpnext/assets/doctype/asset/asset.js +92,Asset Value Adjustment,Úprava hodnoty aktiv
@@ -2400,7 +2399,7 @@
 DocType: Staffing Plan Detail,Estimated Cost Per Position,Odhadovaná cena za pozici
 DocType: Employee,HR-EMP-,HR-EMP-
 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.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Employee Referral,Doporučení zaměstnance
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +166,Employee Referral,Doporučení zaměstnance
 DocType: Student Group,Set 0 for no limit,Nastavte 0 pro žádný limit
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +191,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."
 DocType: Customer,Primary Address and Contact Detail,Primární adresa a podrobnosti kontaktu
@@ -2412,7 +2411,7 @@
 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
 DocType: Shopify Settings,Shopify Tax Account,Nakupujte daňový účet
-apps/erpnext/erpnext/stock/doctype/item/item.py +471,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 +475,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 +257,Leave of type {0} cannot be longer than {1},Absence typu {0} nemůže být delší než {1}
 DocType: Delivery Trip,Optimize Route,Optimalizujte trasu
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,Zkuste plánování operací pro X dní předem.
@@ -2429,7 +2428,7 @@
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Consumed Amount,Spotřebovaném množství
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +69,Net Change in Cash,Čistá změna v hotovosti
 DocType: Assessment Plan,Grading Scale,Klasifikační stupnice
-apps/erpnext/erpnext/stock/doctype/item/item.py +465,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/stock/doctype/item/item.py +469,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 +617,Already completed,již byly dokončeny
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +34,Stock In Hand,Skladem v ruce
 apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +68,"Please add the remaining benefits {0} to the application as \
@@ -2470,7 +2469,7 @@
 DocType: Party Account,Party Account,Party účtu
 apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py +142,Please select Company and Designation,Vyberte prosím společnost a označení
 apps/erpnext/erpnext/config/setup.py +116,Human Resources,Lidské zdroje
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +306,Upper Income,Horní příjmů
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +216,Upper Income,Horní příjmů
 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
@@ -2505,7 +2504,7 @@
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +82,Net Change in Accounts Payable,Čistá Změna účty závazků
 apps/erpnext/erpnext/selling/doctype/customer/customer.py +257,Credit limit has been crossed for customer {0} ({1}/{2}),Kreditní limit byl překročen pro zákazníka {0} ({1} / {2})
 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 +163,Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
+apps/erpnext/erpnext/config/accounts.py +136,Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +26,Pricing,Stanovení ceny
 DocType: Quotation,Term Details,Termín Podrobnosti
 DocType: Employee Incentive,Employee Incentive,Zaměstnanecká pobídka
@@ -2526,7 +2525,7 @@
 DocType: Purchase Invoice,End date of current invoice's period,Datum ukončení doby aktuální faktury je
 DocType: Pricing Rule,Applicable For,Použitelné pro
 DocType: Lab Test,Technician Name,Jméno technika
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +419,"Cannot ensure delivery by Serial No as \
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +425,"Cannot ensure delivery by Serial No as \
 					Item {0} is added with and without Ensure Delivery by \
 					Serial No.","Nelze zajistit dodávku podle sériového čísla, protože je přidána položka {0} se službou Zajistit dodání podle \ sériového čísla"
 DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Odpojit Platba o zrušení faktury
@@ -2545,7 +2544,7 @@
 DocType: Tax Withholding Category,Tax Withholding Rates,Srážkové daně
 DocType: Contract,Contract Period,Období smlouvy
 apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Reklamační proti sériového čísla
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215,'Total',&#39;Celkový&#39;
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +237,'Total',&#39;Celkový&#39;
 DocType: Employee,Permanent Address,Trvalé bydliště
 DocType: Loyalty Program,Collection Tier,Kolekce Tier
 apps/erpnext/erpnext/hr/utils.py +156,From date can not be less than employee's joining date,"Od data nemůže být menší, než je datum spojení"
@@ -2594,7 +2593,7 @@
 DocType: Vehicle,Doors,dveře
 apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +118,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 +733,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
+apps/erpnext/erpnext/stock/doctype/item/item.py +737,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: Employee,Joining Details,Podrobnosti spojení
@@ -2630,7 +2629,7 @@
 DocType: Asset,Depreciation Method,odpisy Metoda
 DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Target,Celkem Target
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +319,Perception Analysis,Analýza vnímání
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +224,Perception Analysis,Analýza vnímání
 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
@@ -2645,17 +2644,17 @@
 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 +263,Main,Hlavní
-apps/erpnext/erpnext/controllers/buying_controller.py +762,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Následující položka {0} není označena jako {1} položka. Můžete je povolit jako {1} položku z jeho položky Master
+apps/erpnext/erpnext/controllers/buying_controller.py +774,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,Následující položka {0} není označena jako {1} položka. Můžete je povolit jako {1} položku z jeho položky Master
 apps/erpnext/erpnext/stock/doctype/item/item.js +74,Variant,Varianta
 apps/erpnext/erpnext/controllers/status_updater.py +163,"For an item {0}, quantity must be negative number",U položky {0} musí být množství záporné číslo
 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 +485,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 +489,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 +1308,Make Purchase Order,Proveďte objednávky
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1309,Make Purchase Order,Proveďte objednávky
 DocType: SMS Center,Send To,Odeslat
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +201,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
@@ -2692,9 +2691,9 @@
 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 +631,BOM {0} must be submitted,BOM {0} musí být předloženy
-apps/erpnext/erpnext/config/accounts.py +504,Share Management,Správa sdílených položek
+apps/erpnext/erpnext/config/accounts.py +429,Share Management,Správa sdílených položek
 DocType: Authorization Control,Authorization Control,Autorizace Control
-apps/erpnext/erpnext/controllers/buying_controller.py +404,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/controllers/buying_controller.py +416,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 +887,Payment,Platba
 apps/erpnext/erpnext/controllers/stock_controller.py +96,"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
@@ -2719,7 +2718,7 @@
 DocType: Item,Barcodes,Čárové kódy
 DocType: Hub Tracked Item,Hub Node,Hub Node
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,"Zadali jste duplicitní položky. Prosím, opravu a zkuste to znovu."
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Associate,Spolupracovník
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Associate,Spolupracovník
 DocType: Asset Movement,Asset Movement,Asset Movement
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +605,Work Order {0} must be submitted,Objednávka práce {0} musí být odeslána
 apps/erpnext/erpnext/accounts/page/pos/pos.js +2227,New Cart,New košík
@@ -2744,7 +2743,7 @@
 apps/erpnext/erpnext/accounts/party.py +292,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 +777,Row {0}: Due Date cannot be before posting date,Řádek {0}: K datu splatnosti nemůže být datum odeslání
+apps/erpnext/erpnext/controllers/accounts_controller.py +786,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 +37,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
@@ -2752,7 +2751,7 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +180,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
 DocType: Leave Type,Earned Leave Frequency,Dosažená frekvence dovolené
-apps/erpnext/erpnext/config/accounts.py +279,Tree of financial Cost Centers.,Strom Nákl.střediska finančních.
+apps/erpnext/erpnext/config/accounts.py +209,Tree of financial Cost Centers.,Strom Nákl.střediska finančních.
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +151,Sub Type,Sub Type
 DocType: Serial No,Delivery Document No,Dodávka dokument č
 DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,Zajistěte dodávku na základě vyrobeného sériového čísla
@@ -2764,14 +2763,14 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +42,"Selling must be checked, if Applicable For is selected as {0}","Prodej musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
 DocType: Production Plan Material Request,Material Request Date,Materiál Request Date
 DocType: Purchase Order Item,Supplier Quotation Item,Dodavatel Nabídka Položka
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +205,Material Consumption is not set in Manufacturing Settings.,Spotřeba materiálu není nastavena v nastavení výroby.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +208,Material Consumption is not set in Manufacturing Settings.,Spotřeba materiálu není nastavena v nastavení výroby.
 DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
 apps/erpnext/erpnext/templates/pages/help.html +46,Visit the forums,Navštivte fóra
 DocType: Student,Student Mobile Number,Student Číslo mobilního telefonu
 DocType: Item,Has Variants,Má varianty
 DocType: Employee Benefit Claim,Claim Benefit For,Nárok na dávku pro
 apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Aktualizace odpovědi
-apps/erpnext/erpnext/public/js/utils.js +512,You have already selected items from {0} {1},Již jste vybrané položky z {0} {1}
+apps/erpnext/erpnext/public/js/utils.js +538,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 +100,Batch ID is mandatory,Číslo šarže je povinné
 DocType: Sales Person,Parent Sales Person,Parent obchodník
@@ -2790,13 +2789,12 @@
 DocType: Vehicle Log,Fuel Price,palivo Cena
 DocType: Bank Guarantee,Margin Money,Margin Money
 DocType: Budget,Budget,Rozpočet
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +79,Set Open,Nastavit Otevřít
-apps/erpnext/erpnext/stock/doctype/item/item.py +283,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 +83,Set Open,Nastavit Otevřít
+apps/erpnext/erpnext/stock/doctype/item/item.py +287,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 +60,"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/hr/utils.py +228,Max exemption amount for {0} is {1},Maximální částka pro výjimku pro {0} je {1}
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Dosažená
 DocType: Student Admission,Application Form Route,Přihláška Trasa
-apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Territory / Customer
 DocType: Healthcare Settings,Patient Encounters in valid days,Setkání pacientů v platných dnech
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +58,Leave Type {0} cannot be allocated since it is leave without pay,"Nechat Typ {0} nemůže být přidělena, neboť se odejít bez zaplacení"
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: Přidělená částka {1} musí být menší než nebo se rovná fakturovat dlužné částky {2}
@@ -2816,7 +2814,7 @@
 DocType: Guardian,Guardian Interests,Guardian Zájmy
 apps/erpnext/erpnext/accounts/doctype/account/account.js +45,Update Account Name / Number,Aktualizovat název účtu / číslo
 DocType: Naming Series,Current Value,Current Value
-apps/erpnext/erpnext/controllers/accounts_controller.py +328,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
+apps/erpnext/erpnext/controllers/accounts_controller.py +331,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: GST Account,GST Account,Účet GST
@@ -2832,7 +2830,6 @@
 DocType: Pricing Rule,Selling,Prodej
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +394,Amount {0} {1} deducted against {2},Množství {0} {1} odečíst proti {2}
 DocType: Sales Person,Name and Employee ID,Jméno a ID zaměstnance
-apps/erpnext/erpnext/accounts/party.py +338,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/hr/doctype/payroll_entry/payroll_entry.py +550,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Žádný výplatní list nebyl předložen za výše uvedené kritéria NEBO platový výpis již předložen
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +160,Duties and Taxes,Odvody a daně
@@ -2853,7 +2850,7 @@
 DocType: Account,Frozen,Zmražený
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +382,Vehicle Type,Typ vozidla
 DocType: Sales Invoice Payment,Base Amount (Company Currency),Základna Částka (Company měna)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1001,Raw Materials,Suroviny
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1002,Raw Materials,Suroviny
 DocType: Payment Reconciliation Payment,Reference Row,referenční Row
 DocType: Installation Note,Installation Time,Instalace Time
 DocType: Sales Invoice,Accounting Details,Účetní detaily
@@ -2885,7 +2882,7 @@
 DocType: Appraisal,For Employee Name,Pro jméno zaměstnance
 DocType: Holiday List,Clear Table,Clear Table
 DocType: Woocommerce Settings,Tax Account,Daňový účet
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +135,Available slots,Dostupné sloty
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +138,Available slots,Dostupné sloty
 DocType: C-Form Invoice Detail,Invoice No,Faktura č
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +408,Make Payment,Zaplatit
 DocType: Room,Room Name,Room Jméno
@@ -2904,7 +2901,6 @@
 DocType: Bank Statement Settings Item,Mapped Header,Mapované záhlaví
 DocType: Employee,Resignation Letter Date,Rezignace Letter Datum
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +115,Not Set,Není nastaveno
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +417,Please set the Date Of Joining for employee {0},Nastavte prosím datum zapojení pro zaměstnance {0}
 DocType: Inpatient Record,Discharge,Vybít
 DocType: Task,Total Billing Amount (via Time Sheet),Celková částka Billing (přes Time Sheet)
@@ -2915,7 +2911,7 @@
 DocType: Chapter,Chapter,Kapitola
 apps/erpnext/erpnext/utilities/user_progress.py +146,Pair,Pár
 DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Výchozí účet bude automaticky aktualizován v POS faktuře při výběru tohoto režimu.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1047,Select BOM and Qty for Production,Vyberte BOM a Množství pro výrobu
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1048,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
@@ -2923,9 +2919,8 @@
 DocType: Maintenance Schedule Detail,Actual Date,Skutečné datum
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +135,Please set the Default Cost Center in {0} company.,Nastavte výchozí cenové centrum ve společnosti {0}.
 DocType: Item,Has Batch No,Má číslo šarže
-apps/erpnext/erpnext/public/js/utils.js +107,Annual Billing: {0},Roční Zúčtování: {0}
 DocType: Shopify Webhook Detail,Shopify Webhook Detail,Nakupujte podrobnosti o Webhooku
-apps/erpnext/erpnext/config/accounts.py +228,Goods and Services Tax (GST India),Daň z zboží a služeb (GST India)
+apps/erpnext/erpnext/config/accounts.py +479,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
 DocType: Asset,Purchase Date,Datum nákupu
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js +33,Could not generate Secret,Nelze generovat tajemství
@@ -2969,7 +2964,7 @@
 DocType: Travel Itinerary,Meal Preference,Předvolba jídla
 ,Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics
 DocType: Purchase Invoice,Availed ITC Central Tax,Využil centrální daň ITC
-DocType: Sales Invoice,Company Address Name,Název adresy společnosti
+DocType: POS Profile,Company Address Name,Název adresy společnosti
 DocType: Work Order,Use Multi-Level BOM,Použijte Multi-Level BOM
 DocType: Bank Reconciliation,Include Reconciled Entries,Zahrnout odsouhlasené zápisy
 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)"
@@ -2987,12 +2982,12 @@
 DocType: Shareholder,Shareholder,Akcionář
 DocType: Purchase Invoice,Additional Discount Amount,Dodatečná sleva Částka
 DocType: Cash Flow Mapper,Position,Pozice
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1799,Get Items from Prescriptions,Získejte položky z předpisu
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1803,Get Items from Prescriptions,Získejte položky z předpisu
 DocType: Patient,Patient Details,Podrobnosti pacienta
 DocType: Inpatient Record,B Positive,B Pozitivní
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +31,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
 			amount",Maximální přínos zaměstnance {0} přesahuje {1} součtem {2} předchozí požadované částky
-apps/erpnext/erpnext/controllers/accounts_controller.py +662,"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 +671,"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 +349,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
@@ -3026,7 +3021,7 @@
 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
-apps/erpnext/erpnext/controllers/accounts_controller.py +368,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 +376,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatný. Měna účtu musí být {1}
 apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py +31,From Date {0} cannot be after employee's relieving Date {1},Od data {0} nemůže být po uvolnění zaměstnance Datum {1}
 DocType: Supplier,Is Internal Supplier,Je interní dodavatel
 DocType: Employee,Create User Permission,Vytvořit oprávnění uživatele
@@ -3055,7 +3050,7 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +970,Quotation,Nabídka
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041,Cannot set a received RFQ to No Quote,Nelze nastavit přijatou RFQ na Žádnou nabídku
 DocType: Salary Slip,Total Deduction,Celkem Odpočet
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +24,Select an account to print in account currency,"Vyberte účet, který chcete vytisknout v měně účtu"
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +22,Select an account to print in account currency,"Vyberte účet, který chcete vytisknout v měně účtu"
 ,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 +218,Cost Updated,Náklady Aktualizováno
@@ -3066,14 +3061,14 @@
 DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Nastavení tabulky dodavatelů
 apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Název plánu hodnocení
 DocType: Work Order Operation,Work Order Operation,Obsluha zakázky
-apps/erpnext/erpnext/stock/doctype/item/item.py +258,Warning: Invalid SSL certificate on attachment {0},Varování: Neplatný certifikát SSL na přílohu {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +262,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: Work Order Operation,Actual Operation Time,Aktuální Provozní doba
 DocType: Authorization Rule,Applicable To (User),Vztahující se na (Uživatel)
 DocType: Purchase Taxes and Charges,Deduct,Odečíst
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +219,Job Description,Popis Práce
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Job Description,Popis Práce
 DocType: Student Applicant,Applied,Aplikovaný
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941,Re-open,Znovu otevřít
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +942,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/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Jméno Guardian2
 DocType: Attendance,Attendance Request,Žádost o účast
@@ -3099,7 +3094,7 @@
 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)
 apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py +24,Company is manadatory for company account,Společnost je řídící na účet společnosti
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1091,"Item Code, warehouse, quantity are required on row","Kód položky, sklad, množství je nutné v řádku"
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1092,"Item Code, warehouse, quantity are required on row","Kód položky, sklad, množství je nutné v řádku"
 DocType: Bank Guarantee,Supplier,Dodavatel
 apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +9,Get From,Získat Z
 apps/erpnext/erpnext/hr/doctype/department/department.js +9,This is a root department and cannot be edited.,Toto je kořenové oddělení a nemůže být editováno.
@@ -3112,14 +3107,14 @@
 apps/erpnext/erpnext/controllers/stock_controller.py +231,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Náklady nebo Rozdíl účet je povinné k bodu {0} jako budou mít dopad na celkovou hodnotu zásob
 DocType: Bank,Bank Name,Název banky
 apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +78,-Above,-Nad
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1300,Leave the field empty to make purchase orders for all suppliers,"Ponechte prázdné pole, abyste mohli objednávat všechny dodavatele"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1301,Leave the field empty to make purchase orders for all suppliers,"Ponechte prázdné pole, abyste mohli objednávat všechny dodavatele"
 DocType: Healthcare Practitioner,Inpatient Visit Charge Item,Poplatek za návštěvu pacienta
 DocType: Vital Signs,Fluid,Tekutina
 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 +107,Item Variant Settings,Nastavení varianty položky
-apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37,Select Company...,Vyberte společnost ...
+apps/erpnext/erpnext/public/js/account_tree_grid.js +57,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/accounts/doctype/sales_invoice/sales_invoice.py +506,{0} is mandatory for Item {1},{0} je povinná k položce {1}
 apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +149,"Item {0}: {1} qty produced, ","Položka {0}: {1} Množství vyrobené,"
@@ -3163,7 +3158,7 @@
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +126,{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: Fee Schedule,In Process,V procesu
 DocType: Authorization Rule,Itemwise Discount,Itemwise Sleva
-apps/erpnext/erpnext/config/accounts.py +92,Tree of financial accounts.,Strom finančních účtů.
+apps/erpnext/erpnext/config/accounts.py +53,Tree of financial accounts.,Strom finančních účtů.
 DocType: Bank Guarantee,Reference Document Type,Referenční Typ dokumentu
 DocType: Cash Flow Mapping,Cash Flow Mapping,Mapování peněžních toků
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +400,{0} against Sales Order {1},{0} proti Prodejní objednávce {1}
@@ -3182,10 +3177,10 @@
 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: Bank Statement Transaction Entry,Receivable Account,Účet pohledávky
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +31,Valid From Date must be lesser than Valid Upto Date.,Platné od data musí být menší než Platné do data.
-apps/erpnext/erpnext/controllers/accounts_controller.py +680,Row #{0}: Asset {1} is already {2},Řádek # {0}: Asset {1} je již {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +689,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 +327,Sales Order to Payment,Prodejní objednávky na platby
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +111,CEO,výkonný ředitel
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,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
@@ -3195,7 +3190,7 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +915,Please select correct account,"Prosím, vyberte správný účet"
 DocType: Salary Structure Assignment,Salary Structure Assignment,Přiřazení struktury platu
 DocType: Purchase Invoice Item,Weight UOM,Hmotnostní jedn.
-apps/erpnext/erpnext/config/accounts.py +510,List of available Shareholders with folio numbers,Seznam dostupných akcionářů s čísly folií
+apps/erpnext/erpnext/config/accounts.py +435,List of available Shareholders with folio numbers,Seznam dostupných akcionářů s čísly folií
 DocType: Salary Structure Employee,Salary Structure Employee,Plat struktura zaměstnanců
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +62,Show Variant Attributes,Zobrazit atributy variantu
 DocType: Student,Blood Group,Krevní Skupina
@@ -3208,10 +3203,10 @@
 DocType: Fiscal Year,Companies,Společnosti
 DocType: Supplier Scorecard,Scoring Setup,Nastavení bodování
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Elektronika
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +366,Debit ({0}),Debet ({0})
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +364,Debit ({0}),Debet ({0})
 DocType: BOM,Allow Same Item Multiple Times,Povolit stejnou položku několikrát
 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/operations/install_fixtures.py +101,Full-time,Na plný úvazek
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +76,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í
@@ -3233,7 +3228,6 @@
 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/data/industry_type.py +51,Technology,Technologie
-apps/erpnext/erpnext/public/js/utils.js +109,Total Unpaid: {0},Celkem nezaplaceno: {0}
 DocType: BOM Website Operation,BOM Website Operation,BOM Webové stránky Provoz
 DocType: Bank Statement Transaction Payment Item,outstanding_amount,nesplacená částka
 DocType: Supplier Scorecard,Supplier Score,Skóre dodavatele
@@ -3266,7 +3260,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Exchange Gain/Loss,Exchange zisk / ztráta
 DocType: Opportunity,Lost Reason,Důvod ztráty
 DocType: Amazon MWS Settings,Enable Amazon,Povolit službu Amazon
-apps/erpnext/erpnext/controllers/accounts_controller.py +319,Row #{0}: Account {1} does not belong to company {2},Řádek # {0}: Účet {1} nepatří společnosti {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +322,Row #{0}: Account {1} does not belong to company {2},Řádek # {0}: Účet {1} nepatří společnosti {2}
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},Nelze najít DocType {0}
 apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Nová adresa
 DocType: Quality Inspection,Sample Size,Velikost vzorku
@@ -3333,7 +3327,7 @@
 apps/erpnext/erpnext/crm/doctype/lead/lead.py +53,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/accounts/page/pos/pos.js +2595,Select Batch No,Vyberte číslo šarže
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +82,Invalid {0}: {1},Neplatný {0}: {1}
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +80,Invalid {0}: {1},Neplatný {0}: {1}
 ,GSTR-1,GSTR-1
 DocType: Fee Validity,Reference Inv,Odkaz Inv
 DocType: Sales Invoice Advance,Advance Amount,Záloha ve výši
@@ -3351,10 +3345,10 @@
 DocType: Item,Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky
 DocType: Tax Withholding Rate,Tax Withholding Rate,Úroková sazba
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +552,Boms,kusovníky
-apps/erpnext/erpnext/stock/doctype/item/item.py +187,Stores,Zásoba
+apps/erpnext/erpnext/stock/doctype/item/item.py +191,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 +45,Ageing Based On,Stárnutí dle
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +15,Ageing Based On,Stárnutí dle
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +103,Appointment cancelled,Jmenování zrušeno
 DocType: Item,End of Life,Konec životnosti
 apps/erpnext/erpnext/demo/setup/setup_data.py +344,Travel,Cestování
@@ -3376,7 +3370,7 @@
 DocType: Travel Request,Any other details,Další podrobnosti
 DocType: Water Analysis,Origin,Původ
 apps/erpnext/erpnext/controllers/status_updater.py +207,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 +1282,Please set recurring after saving,Prosím nastavte opakující se po uložení
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1288,Please set recurring after saving,Prosím nastavte opakující se po uložení
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +874,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
@@ -3416,8 +3410,8 @@
 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.
 DocType: BOM Item,Item operation,Položka položky
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +58,Group by Voucher,Seskupit podle Poukazu
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +327,Are you sure you want to cancel this appointment?,Opravdu chcete tuto schůzku zrušit?
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +56,Group by Voucher,Seskupit podle Poukazu
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +391,Are you sure you want to cancel this appointment?,Opravdu chcete tuto schůzku zrušit?
 DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Balíček ceny pokojů hotelu
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +42,Sales Pipeline,prodejní Pipeline
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +167,Please set default account in Salary Component {0},Prosím nastavit výchozí účet platu Component {0}
@@ -3426,17 +3420,17 @@
 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/subscription/subscription.js +13,Fetch Subscription Updates,Načíst aktualizace předplatného
 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 +707,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
+apps/erpnext/erpnext/controllers/buying_controller.py +719,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
 apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301,Course: ,Chod:
 DocType: Soil Texture,Sandy Loam,Sandy Loam
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +244,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/selling/doctype/sales_order/sales_order.py +246,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: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
 DocType: Notification Control,Expense Claim Approved,Uhrazení výdajů schváleno
 DocType: Purchase Invoice,Set Advances and Allocate (FIFO),Nastavit zálohy a přidělit (FIFO)
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Work Orders created,Nebyly vytvořeny žádné pracovní příkazy
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +403,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/operations/install_fixtures.py +144,Pharmaceutical,Farmaceutické
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +121,Pharmaceutical,Farmaceutické
 apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py +24,You can only submit Leave Encashment for a valid encashment amount,"Chcete-li platnou částku inkasa, můžete odeslat příkaz Opustit zapsání"
 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: Employee Separation,Employee Separation Template,Šablona oddělení zaměstnanců
@@ -3458,11 +3452,11 @@
 DocType: Support Search Source,Post Title Key,Klíč příspěvku
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +232,For Job Card,U pracovní karty
 DocType: Warranty Claim,Raised By,Vznesené
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1552,Prescriptions,Předpisy
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1556,Prescriptions,Předpisy
 DocType: Payment Gateway Account,Payment Account,Platební účet
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +1112,Please specify Company to proceed,Uveďte prosím společnost pokračovat
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +81,Net Change in Accounts Receivable,Čistá změna objemu pohledávek
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +91,Compensatory Off,Vyrovnávací Off
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Compensatory Off,Vyrovnávací Off
 DocType: Job Offer,Accepted,Přijato
 DocType: POS Closing Voucher,Sales Invoices Summary,Souhrn prodejních faktur
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +225,To Party Name,Název strany
@@ -3504,7 +3498,6 @@
 DocType: Sales Invoice Item,Deferred Revenue,Odložené výnosy
 DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,Hotovostní účet bude použit pro vytvoření faktury
 DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,Osvobození podkategorie
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Group / Supplier,Dodavatelská skupina / dodavatel
 DocType: Member,Membership Expiry Date,Datum ukončení členství
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +134,{0} must be negative in return document,{0} musí být negativní ve vratném dokumentu
 DocType: Employee Tax Exemption Proof Submission,Submission Date,Datum podání
@@ -3577,7 +3570,7 @@
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +121,Remaining Balance,Zůstatek účtu
 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 +83,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/stock/doctype/item/item.py +525,Barcode {0} is not a valid {1} code,Čárový kód {0} není platný kód {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +529,Barcode {0} is not a valid {1} code,Čárový kód {0} není platný kód {1}
 apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js +25,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 +141,Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování
@@ -3589,7 +3582,7 @@
 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 +55,Ageing Range 1,Stárnutí Rozsah 1
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +28,Ageing Range 1,Stárnutí Rozsah 1
 DocType: Shopify Settings,Enable Shopify,Povolit funkci Shopify
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220,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.
@@ -3654,7 +3647,7 @@
 DocType: Global Defaults,Hide Currency Symbol,Skrýt symbol měny
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js +281,Sales Opportunities by Source,Možnosti prodeje podle zdroje
 apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informace dárce.
-apps/erpnext/erpnext/config/accounts.py +368,"e.g. Bank, Cash, Credit Card","např. banka, hotovost, kreditní karty"
+apps/erpnext/erpnext/config/accounts.py +287,"e.g. Bank, Cash, Credit Card","např. banka, hotovost, kreditní karty"
 DocType: Job Applicant,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;"
 apps/erpnext/erpnext/stock/doctype/batch/batch.py +124,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Nastavte trvanlivost položek v dny, nastavte vypršení platnosti na základě data výroby a vlastní životnosti"
@@ -3696,7 +3689,7 @@
 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/controllers/accounts_controller.py +369, or ,nebo
+apps/erpnext/erpnext/controllers/accounts_controller.py +377, 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/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +127,Utility Expenses,Utility Náklady
@@ -3707,7 +3700,7 @@
 DocType: Buying Settings,Default Buying Price List,Výchozí Nákup Ceník
 DocType: Payroll Entry,Salary Slip Based on Timesheet,Plat Slip na základě časového rozvrhu
 apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +55,Buying Rate,Rychlost nákupu
-apps/erpnext/erpnext/controllers/buying_controller.py +590,Row {0}: Enter location for the asset item {1},Řádek {0}: Zadejte umístění položky aktiv {1}
+apps/erpnext/erpnext/controllers/buying_controller.py +602,Row {0}: Enter location for the asset item {1},Řádek {0}: Zadejte umístění položky aktiv {1}
 DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
 DocType: Company,About the Company,O společnosti
 DocType: Notification Control,Sales Order Message,Prodejní objednávky Message
@@ -3741,7 +3734,7 @@
 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 +353,Not Paid and Not Delivered,Nezaplatil a není doručení
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +359,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: Shopify Settings,Webhooks Details,Webhooks Podrobnosti
@@ -3763,7 +3756,7 @@
 apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +883,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/operations/install_fixtures.py +77,Arrear,nedoplatek
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +52,Arrear,nedoplatek
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Depreciation Amount during the period,Odpisy hodnoty v průběhu období
 DocType: Sales Invoice,Is Return (Credit Note),Je návrat (kreditní poznámka)
 apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js +26,Start Job,Spustit úlohu
@@ -3813,14 +3806,14 @@
 DocType: Employee Education,Class / Percentage,Třída / Procento
 DocType: Shopify Settings,Shopify Settings,Shopify Nastavení
 DocType: Amazon MWS Settings,Market Place ID,ID místa na trhu
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +122,Head of Marketing and Sales,Vedoucí marketingu a prodeje
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Income Tax,Daň z příjmů
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +97,Head of Marketing and Sales,Vedoucí marketingu a prodeje
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +50,Income Tax,Daň z příjmů
 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 +101,Go to Letterheads,Přejděte na Letterheads
 DocType: Subscription,Cancel At End Of Period,Zrušit na konci období
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +114,Property already added,Vlastnictví již bylo přidáno
 DocType: Item Supplier,Item Supplier,Položka Dodavatel
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1383,Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no"
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1389,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 +928,Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +435,No Items selected for transfer,Nebyly vybrány žádné položky pro přenos
 apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Všechny adresy.
@@ -3856,7 +3849,7 @@
 apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Student Přijímací
 apps/erpnext/erpnext/accounts/party.py +421,{0} {1} is disabled,{0} {1} je zakázán
 DocType: Supplier,Billing Currency,Fakturace Měna
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +175,Extra Large,Extra Velké
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +152,Extra Large,Extra Velké
 DocType: Loan,Loan Application,Žádost o půjčku
 DocType: Crop,Scientific Name,Odborný název
 DocType: Healthcare Service Unit,Service Unit Type,Typ servisní jednotky
@@ -3873,13 +3866,13 @@
 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/operations/install_fixtures.py +174,Large,Velký
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +151,Large,Velký
 DocType: Bank Statement Settings,Bank Statement Settings,Nastavení bankovního výpisu
 DocType: Shopify Settings,Customer Settings,Nastavení zákazníka
 DocType: Homepage Featured Product,Homepage Featured Product,Úvodní Doporučené zboží
 apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js +12,View Orders,Zobrazit objednávky
 DocType: Marketplace Settings,Marketplace URL (to hide and update label),Adresa URL tržiště (skrýt a aktualizovat štítek)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +229,All Assessment Groups,Všechny skupiny Assessment
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +206,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
 DocType: Shopify Settings,App Type,Typ aplikace
 apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py +401,Total {0} ({1}),Celkem {0} ({1})
@@ -3895,22 +3888,22 @@
 DocType: Work 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 +305,Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
+apps/erpnext/erpnext/config/accounts.py +235,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: Additional Salary,Salary Component Type,Typ platového komponentu
 DocType: Sensitivity Test Items,Sensitivity Test Items,Položky testu citlivosti
 DocType: Project Update,Project Update,Aktualizace projektu
 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 +166,Quotation {0} is cancelled,Nabídka {0} je zrušena
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +132,Total Outstanding Amount,Celková dlužná částka
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +165,Quotation {0} is cancelled,Nabídka {0} je zrušena
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +139,Total Outstanding Amount,Celková dlužná částka
 DocType: Sales Partner,Targets,Cíle
 apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +40,Please register the SIREN number in the company information file,Zaregistrujte prosím číslo SIREN v informačním souboru společnosti
 DocType: Email Digest,Sales Orders to Bill,Prodejní příkazy k Billu
 DocType: Price List,Price List Master,Ceník Master
 DocType: GST Account,CESS Account,Účet CESS
 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."
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1184,Link to Material Request,Odkaz na materiálovou žádost
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1185,Link to Material Request,Odkaz na materiálovou žádost
 apps/erpnext/erpnext/templates/pages/help.html +35,Forum Activity,Aktivita fóra
 ,S.O. No.,SO Ne.
 DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,Položka položek transakce bankovního výpisu
@@ -3932,7 +3925,7 @@
 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 +70,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 +69,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:
@@ -4019,7 +4012,7 @@
 DocType: Item,Total Projected Qty,Celková předpokládaná Množství
 DocType: Monthly Distribution,Distribution Name,Distribuce Name
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +56,Include UOM,Zahrnout UOM
-apps/erpnext/erpnext/stock/stock_ledger.py +478,"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 +482,"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 +341,Quality Inspection required for Item {0},Kontrola kvality potřebný k bodu {0}
 DocType: Location,Parent Location,Umístění rodiče
@@ -4044,12 +4037,12 @@
 DocType: Lab Test,LabTest Approver,Nástroj LabTest
 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
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1083,Work Orders Created: {0},Vytvořené zakázky: {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1084,Work Orders Created: {0},Vytvořené zakázky: {0}
 DocType: Sales Invoice,Sales Team1,Sales Team1
-apps/erpnext/erpnext/stock/doctype/item/item.py +574,Item {0} does not exist,Bod {0} neexistuje
+apps/erpnext/erpnext/stock/doctype/item/item.py +578,Item {0} does not exist,Bod {0} neexistuje
 DocType: Sales Invoice,Customer Address,Zákazník Address
 DocType: Loan,Loan Details,půjčka Podrobnosti
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to setup post company fixtures,Nepodařilo se nastavit příslušenství společnosti
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +62,Failed to setup post company fixtures,Nepodařilo se nastavit příslušenství společnosti
 DocType: Company,Default Inventory Account,Výchozí účet inventáře
 apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +193,The folio numbers are not matching,Čísla fólií se neodpovídají
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +304,Payment Request for {0},Žádost o platbu za {0}
@@ -4073,7 +4066,7 @@
 DocType: Purchase Invoice,Select Supplier Address,Vybrat Dodavatel Address
 apps/erpnext/erpnext/public/js/event.js +27,Add Employees,Přidejte Zaměstnanci
 DocType: Purchase Invoice Item,Quality Inspection,Kontrola kvality
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +171,Extra Small,Extra Malé
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +148,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 +1103,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í
@@ -4083,7 +4076,7 @@
 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 +794,Can only make payment against unbilled {0},Lze provést pouze platbu proti nevyfakturované {0}
-apps/erpnext/erpnext/controllers/selling_controller.py +111,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
+apps/erpnext/erpnext/controllers/selling_controller.py +114,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
 DocType: Sales Invoice,Allocate Advances Automatically (FIFO),Automaticky přidělit předdavky (FIFO)
 DocType: Volunteer,Volunteer,Dobrovolník
 DocType: Buying Settings,Subcontract,Subdodávka
@@ -4105,7 +4098,7 @@
 DocType: Healthcare Practitioner,Inpatient Visit Charge,Poplatek za návštěvu v nemocnici
 DocType: Account,Expense Account,Účtet nákladů
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Software
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +178,Colour,Barevné
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Colour,Barevné
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Plan Assessment Criteria
 apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card_dashboard.py +8,Transactions,Transakce
 apps/erpnext/erpnext/stock/doctype/batch/batch.py +123,Expiry date is mandatory for selected item,Datum vypršení platnosti je pro vybranou položku povinné
@@ -4119,7 +4112,7 @@
 DocType: Patient,Personal and Social History,Osobní a sociální historie
 apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,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 +608,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 +617,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/clinical_procedure_template/clinical_procedure_template.js +88,Change Code,Změnit kód
 DocType: Purchase Invoice Item,Valuation Rate,Ocenění
@@ -4130,7 +4123,7 @@
 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/assets/doctype/asset/asset.py +219,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,Odpisový řádek {0}: Další datum odpisu nemůže být před datem nákupu
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Datum zahájení projektu
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +36,Until,Dokud
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +26,Until,Dokud
 DocType: Rename Tool,Rename Log,Přejmenovat Přihlásit
 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
@@ -4154,7 +4147,7 @@
 DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
 DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačené Návštěvnost
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +256,Creating Payment Entries......,Vytváření položek platby ......
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Researcher,Výzkumník
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,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}
 ,Consolidated Financial Statement,Konsolidovaný finanční výkaz
@@ -4165,7 +4158,7 @@
 DocType: Purchase Order Item,Returned Qty,Vrácené Množství
 DocType: Student,Exit,Východ
 apps/erpnext/erpnext/accounts/doctype/account/account.py +163,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/setup/setup_wizard/setup_wizard.py +30,Failed to install presets,Instalace předvoleb se nezdařila
 DocType: Healthcare Service Unit Type,UOM Conversion in Hours,Převod UOM v hodinách
 DocType: Contract,Signee Details,Signee Podrobnosti
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{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í.
@@ -4182,7 +4175,7 @@
 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/operations/install_fixtures.py +214,Probationary Period,Zkušební doba
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Probationary Period,Zkušební doba
 DocType: Purchase Taxes and Charges Template,Is Inter State,Je Inter State
 apps/erpnext/erpnext/config/hr.py +269,Shift Management,Shift Management
 DocType: Customer Group,Only leaf nodes are allowed in transaction,Pouze koncové uzly jsou povoleny v transakci
@@ -4198,7 +4191,7 @@
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Chcete-li datetime
 apps/erpnext/erpnext/config/selling.py +308,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 +241,Printed On,Vytištěno na
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +263,Printed On,Vytištěno na
 DocType: Clinical Procedure Template,Clinical Procedure Template,Šablona klinického postupu
 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
@@ -4219,7 +4212,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Vydavatelé novin
 apps/erpnext/erpnext/hr/utils.py +154,Future dates not allowed,Budoucí data nejsou povolená
 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 +120,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 +119,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
@@ -4271,7 +4264,7 @@
 DocType: Shopify Settings,Last Sync Datetime,Poslední datum synchronizace
 DocType: Landed Cost Item,Receipt Document Type,Příjem Document Type
 DocType: Daily Work Summary Settings,Select Companies,Zvolit firem
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +320,Proposal/Price Quote,Návrh / cenová nabídka
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +225,Proposal/Price Quote,Návrh / cenová nabídka
 DocType: Antibiotic,Healthcare,Zdravotní péče
 DocType: Target Detail,Target Detail,Target Detail
 apps/erpnext/erpnext/stock/doctype/item/item.js +67,Single Variant,Jediný variant
@@ -4336,7 +4329,7 @@
 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 +491,{0} {1} is cancelled or closed,{0} {1} je zrušen nebo zavřené
+apps/erpnext/erpnext/controllers/buying_controller.py +503,{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 +89,Net Cash from Investing,Čistý peněžní tok z investiční
@@ -4363,7 +4356,7 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +999,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 +264,Closing (Dr),Uzavření (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +271,Closing (Dr),Uzavření (Dr)
 DocType: Cheque Print Template,Cheque Size,Šek Velikost
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +284,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.
@@ -4379,13 +4372,13 @@
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Fakturovaná částka
 DocType: Share Transfer,(including),(počítaje v to)
 DocType: Asset,Double Declining Balance,Double degresivní
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +189,Closed order cannot be cancelled. Unclose to cancel.,Uzavřená objednávka nemůže být zrušen. Otevřít zrušit.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +188,Closed order cannot be cancelled. Unclose to cancel.,Uzavřená objednávka nemůže být zrušen. Otevřít zrušit.
 apps/erpnext/erpnext/config/hr.py +120,Payroll Setup,Nastavení mzdy
 DocType: Amazon MWS Settings,Synch Products,Synchronizace produktů
 DocType: Loyalty Point Entry,Loyalty Program,Věrnostní program
 DocType: Student Guardian,Father,Otec
 apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py +59,Support Tickets,Vstupenky na podporu
-apps/erpnext/erpnext/controllers/accounts_controller.py +694,'Update Stock' cannot be checked for fixed asset sale,"""Aktualizace Sklad"" nemohou být zaškrtnuty na prodej dlouhodobého majetku"
+apps/erpnext/erpnext/controllers/accounts_controller.py +703,'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
@@ -4395,11 +4388,11 @@
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +219,Dispatch State,Stav odeslání
 apps/erpnext/erpnext/config/hr.py +399,Leave Management,Správa absencí
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +17,Groups,Skupiny
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +53,Group by Account,Seskupit podle účtu
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +51,Group by Account,Seskupit podle účtu
 DocType: Purchase Invoice,Hold Invoice,Podržte fakturu
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +37,Please select Employee,Vyberte prosím zaměstnance
 DocType: Sales Order,Fully Delivered,Plně Dodáno
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +304,Lower Income,S nižšími příjmy
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +214,Lower Income,S nižšími příjmy
 DocType: Restaurant Order Entry,Current Order,Aktuální objednávka
 apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +25,Number of serial nos and quantity must be the same,Číslo sériového čísla a množství musí být stejné
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275,Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
@@ -4433,7 +4426,7 @@
 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 +207,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 +86,Value or Qty,Hodnota nebo Množství
+apps/erpnext/erpnext/public/js/stock_analytics.js +48,Value or Qty,Hodnota nebo Množství
 DocType: Payment Terms Template,Payment Terms,Platební podmínky
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +485,Productions Orders cannot be raised for:,Productions Objednávky nemůže být zvýšena pro:
 apps/erpnext/erpnext/utilities/user_progress.py +147,Minute,Minuta
@@ -4456,8 +4449,8 @@
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +144,Credit To account must be a Balance Sheet account,Připsat na účet musí být účtu Rozvaha
 DocType: Donor,Donor,Dárce
 DocType: Global Defaults,Disable In Words,Zakázat ve slovech
-apps/erpnext/erpnext/stock/doctype/item/item.py +70,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 +103,Quotation {0} not of type {1},Nabídka {0} není typu {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +74,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 +102,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/education/doctype/fees/fees.js +108,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"
@@ -4517,10 +4510,10 @@
 DocType: Stock Settings,Item Naming By,Položka Pojmenování By
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Další období Uzávěrka Entry {0} byla podána po {1}
 DocType: Work Order,Material Transferred for Manufacturing,Materiál Přenesená pro výrobu
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +51,Account {0} does not exists,Účet {0} neexistuje
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1604,Select Loyalty Program,Vyberte Věrnostní program
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +49,Account {0} does not exists,Účet {0} neexistuje
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1608,Select Loyalty Program,Vyberte Věrnostní program
 DocType: Project,Project Type,Typ projektu
-apps/erpnext/erpnext/projects/doctype/task/task.py +154,Child Task exists for this Task. You can not delete this Task.,Dětská úloha existuje pro tuto úlohu. Tuto úlohu nelze odstranit.
+apps/erpnext/erpnext/projects/doctype/task/task.py +157,Child Task exists for this Task. You can not delete this Task.,Dětská úloha existuje pro tuto úlohu. Tuto úlohu nelze odstranit.
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +17,Either target qty or target amount is mandatory.,Buď cílové množství nebo cílová částka je povinná.
 apps/erpnext/erpnext/config/projects.py +56,Cost of various activities,Náklady na různých aktivit
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Nastavení událostí do {0}, protože zaměstnanec připojena k níže prodejcům nemá ID uživatele {1}"
@@ -4537,7 +4530,7 @@
 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 +144,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 +143,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)
 DocType: Assessment Plan,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ů
@@ -4554,22 +4547,21 @@
 DocType: Setup Progress,Setup Progress,Pokročilé nastavení
 DocType: Expense Claim,Approval Status,Stav schválení
 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 +158,Wire Transfer,Bankovní převod
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Wire Transfer,Bankovní převod
 apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +93,Check all,Zkontrolovat vše
 ,Issued Items Against Work Order,Vydávané položky proti pracovní zakázce
 ,BOM Stock Calculated,Výpočet zásob BOM
 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
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +39,Unclosed Fiscal Years Profit / Loss (Credit),Neuzavřený fiskálních let Zisk / ztráta (Credit)
 DocType: Sales Invoice,Time Sheets,čas listy
 DocType: Healthcare Service Unit Type,Change In Item,Změna položky
 DocType: Payment Gateway Account,Default Payment Request Message,Výchozí Platba Request Message
 DocType: Retention Bonus,Bonus Amount,Bonusová částka
 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/accounts/report/general_ledger/general_ledger.py +378,Balance ({0}),Zůstatek ({0})
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +376,Balance ({0}),Zůstatek ({0})
 DocType: Loyalty Point Entry,Redeem Against,Vykoupit proti
-apps/erpnext/erpnext/config/accounts.py +157,Banking and Payments,Bankovnictví a platby
+apps/erpnext/erpnext/config/accounts.py +130,Banking and Payments,Bankovnictví a platby
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +99,Please enter API Consumer Key,Zadejte prosím klíč API pro spotřebitele
 ,Welcome to ERPNext,Vítejte na ERPNext
 apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Lead na nabídku
@@ -4612,16 +4604,15 @@
 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
 ,Item Balance (Simple),Balance položky (jednoduché)
-apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Směnky vznesené dodavately
+apps/erpnext/erpnext/config/accounts.py +19,Bills raised by Suppliers.,Směnky vznesené dodavately
 DocType: POS Profile,Write Off Account,Odepsat účet
 DocType: Patient Appointment,Get prescribed procedures,Získejte předepsané postupy
 DocType: Sales Invoice,Redemption Account,Účet zpětného odkupu
 DocType: Purchase Invoice Item,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/setup/setup_wizard/setup_wizard.py +66,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 +873,Please select BOM against item {0},Vyberte prosím kusovníku podle položky {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +879,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
 DocType: Shopping Cart Settings,Show Stock Quantity,Zobrazit množství zásob
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +77,Net Cash from Operations,Čistý peněžní tok z provozní
@@ -4670,7 +4661,7 @@
 apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +555,Change POS Profile,Změňte profil POS
 DocType: Bank Reconciliation Detail,Clearance Date,Výprodej Datum
 DocType: Delivery Settings,Dispatch Notification Template,Šablona oznámení o odeslání
-apps/erpnext/erpnext/stock/doctype/item/item.py +738,"Asset is already exists against the item {0}, you cannot change the has serial no value","Aktivum již existuje proti položce {0}, nemůžete měnit hodnotu sériové hodnoty"
+apps/erpnext/erpnext/stock/doctype/item/item.py +742,"Asset is already exists against the item {0}, you cannot change the has serial no value","Aktivum již existuje proti položce {0}, nemůžete měnit hodnotu sériové hodnoty"
 apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Report,Zpráva o hodnocení
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +26,Get Employees,Získejte zaměstnance
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Gross Purchase Amount is mandatory,Gross Částka nákupu je povinná
@@ -4700,7 +4691,7 @@
 DocType: BOM Explosion Item,Source Warehouse,Zdroj Warehouse
 DocType: Installation Note,Installation Date,Datum instalace
 apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Sdílet knihu
-apps/erpnext/erpnext/controllers/accounts_controller.py +668,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 +677,Row #{0}: Asset {1} does not belong to company {2},Řádek # {0}: {1} Asset nepatří do společnosti {2}
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +114,Sales Invoice {0} created,Byla vytvořena prodejní faktura {0}
 DocType: Employee,Confirmation Date,Potvrzení Datum
 DocType: Inpatient Occupancy,Check Out,Překontrolovat
@@ -4771,7 +4762,7 @@
 DocType: Purchase Invoice,Terms,Podmínky
 apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +10,Select Days,Vyberte dny
 DocType: Academic Term,Term Name,termín Name
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +372,Credit ({0}),Úvěr ({0})
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +370,Credit ({0}),Úvěr ({0})
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +503,Creating Salary Slips...,Vytváření salicích ...
 apps/erpnext/erpnext/hr/doctype/department/department.js +14,You cannot edit root node.,Nelze upravit kořenový uzel.
 DocType: Buying Settings,Purchase Order Required,Vydaná objednávka je vyžadována
@@ -4862,7 +4853,7 @@
 DocType: Employee Transfer,Employee Transfer Details,Podrobnosti o převodu zaměstnanců
 apps/erpnext/erpnext/selling/doctype/customer/customer.py +263,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 +79,Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
+apps/erpnext/erpnext/config/accounts.py +40,Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
 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 +179,No Students in,Žádné studenty v
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +180,Add more items or open full form,Přidat další položky nebo otevřené plné formě
@@ -4886,7 +4877,6 @@
 DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Ověření prodejní ceny položky proti nákupní ceně nebo ocenění
 DocType: Fee Schedule,Fee Schedule,poplatek Plán
 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 +129,Date of Birth cannot be greater than today.,Datum narození nemůže být větší než dnes.
 ,Stock Ageing,Reklamní Stárnutí
 DocType: Travel Request,"Partially Sponsored, Require Partial Funding","Částečně sponzorované, vyžadují částečné financování"
@@ -4896,7 +4886,7 @@
 apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243,Batch: ,Dávka:
 DocType: Volunteer,Afternoon,Odpoledne
 DocType: Loyalty Program,Loyalty Program Help,Nápověda věrnostního programu
-apps/erpnext/erpnext/controllers/accounts_controller.py +312,{0} '{1}' is disabled,{0} '{1}' je vypnuté
+apps/erpnext/erpnext/controllers/accounts_controller.py +315,{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í.
@@ -4909,13 +4899,13 @@
 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 +140,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/controllers/accounts_controller.py +143,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 +79,Project {0} already exists,Projekt {0} již existuje
 DocType: Clinical Procedure,Nursing User,Ošetřujícího uživatele
 DocType: Employee Benefit Application,Payroll Period,Mzdové období
 DocType: Plant Analysis,Plant Analysis Criterias,Kritéria analýzy rostlin
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +239,Serial No {0} does not belong to Batch {1},Sériové číslo {0} nepatří do skupiny Batch {1}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +220,Responsibilities,Odpovědnost
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,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: Account,Capital Work in Progress,Kapitálová práce probíhá
@@ -4930,18 +4920,18 @@
 DocType: Item,Safety Stock,Bezpečné skladové množství
 DocType: Healthcare Settings,Healthcare Settings,Nastavení zdravotní péče
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html +8,Total Allocated Leaves,Celkové přidělené listy
-apps/erpnext/erpnext/projects/doctype/task/task.py +54,Progress % for a task cannot be more than 100.,Pokrok% za úkol nemůže být více než 100.
+apps/erpnext/erpnext/projects/doctype/task/task.py +57,Progress % for a task cannot be more than 100.,Pokrok% za úkol nemůže být více než 100.
 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 +503,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 +507,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/assets/doctype/asset/asset.py +54,Item {0} must be a Fixed Asset Item,Item {0} musí být dlouhodobá aktiva položka
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +286,HSN,HSN
 apps/erpnext/erpnext/stock/doctype/item/item.js +427,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 +131,Debit Note Amount,Částka pro debetní poznámku
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +138,Debit Note Amount,Částka pro debetní poznámku
 DocType: Project Update,Not Updated,Neaktualizováno
 apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +107,"There are inconsistencies between the rate, no of shares and the amount calculated","Existují nesrovnalosti mezi sazbou, počtem akcií a vypočítanou částkou"
 apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py +39,You are not present all day(s) between compensatory leave request days,Nejste přítomni celý den (dní) mezi dny žádosti o náhradní dovolenou
@@ -4971,7 +4961,7 @@
 DocType: Loyalty Program,Multiple Tier Program,Vícevrstvý program
 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/buying/page/purchase_analytics/purchase_analytics.js +116,All Supplier Groups,Všechny skupiny dodavatelů
+apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py +27,All Supplier Groups,Všechny skupiny dodavatelů
 DocType: Employee Boarding Activity,Required for Employee Creation,Požadováno pro vytváření zaměstnanců
 apps/erpnext/erpnext/accounts/doctype/account/account.py +214,Account Number {0} already used in account {1},Číslo účtu {0} již použito v účtu {1}
 DocType: GoCardless Mandate,Mandate,Mandát
@@ -4979,11 +4969,11 @@
 DocType: Hotel Room Reservation,Booked,Rezervováno
 DocType: Detected Disease,Tasks Created,Úkoly byly vytvořeny
 DocType: Purchase Invoice Item,Rate,Cena
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +107,Intern,Internovat
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +82,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/operations/install_fixtures.py +76,Basic,Základní
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +51,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/accounts/doctype/journal_entry/journal_entry.py +154,Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni"
@@ -4996,7 +4986,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Letecká linka
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +886,Issue Material,Vydání Material
 apps/erpnext/erpnext/config/integrations.py +32,Connect Shopify with ERPNext,Connect Shopify s ERPNext
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1160,For Warehouse,Pro Sklad
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1161,For Warehouse,Pro Sklad
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +92,Delivery Notes {0} updated,Dodací poznámky {0} byly aktualizovány
 DocType: Employee,Offer Date,Nabídka Date
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +35,Quotations,Citace
@@ -5006,7 +4996,7 @@
 DocType: Purchase Invoice Item,Serial No,Výrobní číslo
 apps/erpnext/erpnext/hr/doctype/loan/loan.py +129,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 +61,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 +60,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: Sales Invoice,Customer PO Details,Podrobnosti PO zákazníka
@@ -5017,14 +5007,14 @@
 DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,Vyhláška o osvobození od daně z příjmů zaměstnanců
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +451,All Territories,Všechny území
 apps/erpnext/erpnext/hr/utils.py +216,Please set leave policy for employee {0} in Employee / Grade record,Pro zaměstnance {0} nastavte v kalendáři zaměstnance / plat
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1466,Invalid Blanket Order for the selected Customer and Item,Neplatná objednávka prázdné objednávky pro vybraného zákazníka a položku
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1472,Invalid Blanket Order for the selected Customer and Item,Neplatná objednávka prázdné objednávky pro vybraného zákazníka a položku
 apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49,Add Multiple Tasks,Přidat více úkolů
 DocType: Purchase Invoice,Items,Položky
 apps/erpnext/erpnext/crm/doctype/contract/contract.py +38,End Date cannot be before Start Date.,Datum ukončení nemůže být před datem zahájení.
 apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +33,Student is already enrolled.,Student je již zapsáno.
 DocType: Fiscal Year,Year Name,Jméno roku
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +323,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
-apps/erpnext/erpnext/controllers/buying_controller.py +760,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Následující položky {0} nejsou označeny jako položka {1}. Můžete je povolit jako {1} položku z jeho položky Master
+apps/erpnext/erpnext/controllers/buying_controller.py +772,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,Následující položky {0} nejsou označeny jako položka {1}. Můžete je povolit jako {1} položku z jeho položky Master
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +108,PDC/LC Ref,PDC / LC Ref
 DocType: Production Plan Item,Product Bundle Item,Product Bundle Item
 DocType: Sales Partner,Sales Partner Name,Sales Partner Name
@@ -5043,12 +5033,12 @@
 DocType: Issue,Opening Time,Otevírací doba
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +97,From and To dates required,Data OD a DO jsou vyžadována
 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 +756,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/stock/doctype/item/item.py +760,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: Contract,Unfulfilled,Nesplněno
 DocType: Delivery Note Item,From Warehouse,Ze skladu
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +68,No employees for the mentioned criteria,Žádní zaměstnanci nesplnili uvedená kritéria
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1032,No Items with Bill of Materials to Manufacture,Žádné položky s Billem materiálů k výrobě
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1033,No Items with Bill of Materials to Manufacture,Žádné položky s Billem materiálů k výrobě
 DocType: Shopify Settings,Default Customer,Výchozí zákazník
 DocType: Sales Stage,Stage Name,Pseudonym
 DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
@@ -5059,7 +5049,7 @@
 apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py +59,User {0} is already assigned to Healthcare Practitioner {1},Uživatel {0} je již přiřazen zdravotnickému lékaři {1}
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +187,Make Sample Retention Stock Entry,Vytvořte položku Sample Retention Stock
 DocType: Purchase Taxes and Charges,Valuation and Total,Oceňování a Total
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +321,Negotiation/Review,Vyjednávání / přezkum
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +226,Negotiation/Review,Vyjednávání / přezkum
 DocType: Leave Encashment,Encashment Amount,Část inkasa
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Scorecards
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +159,Expired Batches,Zaniklé dávky
@@ -5083,14 +5073,14 @@
 DocType: Payroll Entry,Payroll Frequency,Mzdové frekvence
 DocType: Lab Test Template,Sensitivity,Citlivost
 apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py +132,Sync has been temporarily disabled because maximum retries have been exceeded,"Synchronizace byla dočasně deaktivována, protože byly překročeny maximální počet opakování"
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1014,Raw Material,Surovina
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1015,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 +56,Plants and Machineries,Rostliny a strojní vybavení
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po slevě Částka
 DocType: Patient,Inpatient Status,Stavy hospitalizace
 DocType: Daily Work Summary Settings,Daily Work Summary Settings,Každodenní práci Souhrnné Nastavení
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +1298,Selected Price List should have buying and selling fields checked.,Vybraný ceník by měl kontrolovat nákupní a prodejní pole.
-apps/erpnext/erpnext/controllers/buying_controller.py +681,Please enter Reqd by Date,Zadejte Reqd podle data
+apps/erpnext/erpnext/controllers/buying_controller.py +693,Please enter Reqd by Date,Zadejte Reqd podle data
 DocType: Payment Entry,Internal Transfer,vnitřní Převod
 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á
@@ -5114,7 +5104,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +73,Queued for replacing the BOM. It may take a few minutes.,Naléhá na výměnu kusovníku. Může to trvat několik minut.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +385,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 +286,Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
-apps/erpnext/erpnext/config/accounts.py +167,Match Payments with Invoices,Zápas platby fakturami
+apps/erpnext/erpnext/config/accounts.py +140,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
@@ -5124,7 +5114,7 @@
 apps/erpnext/erpnext/templates/generators/item.html +96,Add to Cart,Přidat do košíku
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +197,Group By,Seskupit podle
 DocType: Guardian,Interests,zájmy
-apps/erpnext/erpnext/config/accounts.py +336,Enable / disable currencies.,Povolit / zakázat měny.
+apps/erpnext/erpnext/config/accounts.py +266,Enable / disable currencies.,Povolit / zakázat měny.
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +553,Could not submit some Salary Slips,Nelze odeslat některé výplatní pásky
 DocType: Exchange Rate Revaluation,Get Entries,Získejte položky
 DocType: Production Plan,Get Material Request,Získat Materiál Request
@@ -5138,10 +5128,10 @@
 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 +97,Total Present,Celkem Present
 DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-YYYY.-
-apps/erpnext/erpnext/config/accounts.py +122,Accounting Statements,účetní závěrka
+apps/erpnext/erpnext/config/accounts.py +83,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 +875,Please select Qty against item {0},Zvolte prosím množství v položce {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +881,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 +33,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 +183,You are not authorized to approve leaves on Block Dates,Nejste oprávněni schvalovat listí na bloku Termíny
@@ -5154,7 +5144,7 @@
 DocType: Item,Default Material Request Type,Výchozí typ požadavku na zásobování
 DocType: Supplier Scorecard,Evaluation Period,Hodnocené období
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,Neznámý
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1031,Work Order not created,Pracovní příkaz nebyl vytvořen
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1032,Work Order not created,Pracovní příkaz nebyl vytvořen
 apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py +36,"An amount of {0} already claimed for the component {1},\
 						 set the amount equal or greater than {2}","Část {0} již byla nárokována pro složku {1}, \ nastavte částku rovnající se nebo větší než {2}"
 DocType: Shipping Rule,Shipping Rule Conditions,Přepravní Článek Podmínky
@@ -5284,7 +5274,7 @@
 DocType: Subscription Settings,Grace Period,Doba odkladu
 DocType: Item Alternative,Alternative Item Name,Název alternativní položky
 apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Parent Item {0} nesmí být skladem
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +187,Website Listing,Seznam webových stránek
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +164,Website Listing,Seznam webových stránek
 apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Všechny výrobky nebo služby.
 DocType: Email Digest,Open Quotations,Otevřené nabídky
 DocType: Expense Claim,More Details,Další podrobnosti
@@ -5312,10 +5302,10 @@
 DocType: Project Update,Problematic/Stuck,Problém / Stuck
 DocType: Tax Rule,Billing State,Fakturace State
 DocType: Share Transfer,Transfer,Převod
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +264,Work Order {0} must be cancelled before cancelling this Sales Order,Objednávka práce {0} musí být zrušena před zrušením této objednávky
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +268,Work Order {0} must be cancelled before cancelling this Sales Order,Objednávka práce {0} musí být zrušena před zrušením této objednávky
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +1008,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 +177,Due Date is mandatory,Datum splatnosti je povinné
+apps/erpnext/erpnext/controllers/accounts_controller.py +180,Due Date is mandatory,Datum splatnosti je povinné
 apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Přírůstek pro atribut {0} nemůže být 0
 DocType: Employee Benefit Claim,Benefit Type and Amount,Typ příspěvku a částka
 apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Pokoje objednané
@@ -5329,7 +5319,7 @@
 DocType: Disease,Treatment Period,Doba léčby
 DocType: Travel Itinerary,Travel Itinerary,Cestovní itinerář
 apps/erpnext/erpnext/education/api.py +336,Result already Submitted,Výsledek již byl odeslán
-apps/erpnext/erpnext/controllers/buying_controller.py +197,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervovaný sklad je povinný pro položku {0} v dodávaných surovinách
+apps/erpnext/erpnext/controllers/buying_controller.py +209,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Rezervovaný sklad je povinný pro položku {0} v dodávaných surovinách
 ,Inactive Customers,neaktivní zákazníci
 DocType: Student Admission Program,Maximum Age,Maximální věk
 apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,Počkejte 3 dny před odesláním připomínek.
@@ -5368,7 +5358,7 @@
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +197,Invoice {0} no longer exists,Faktura {0} již neexistuje
 DocType: Guardian Interest,Guardian Interest,Guardian Zájem
 DocType: Volunteer,Availability,Dostupnost
-apps/erpnext/erpnext/config/accounts.py +357,Setup default values for POS Invoices,Nastavení výchozích hodnot pro POS faktury
+apps/erpnext/erpnext/config/accounts.py +544,Setup default values for POS Invoices,Nastavení výchozích hodnot pro POS faktury
 apps/erpnext/erpnext/config/hr.py +248,Training,Výcvik
 DocType: Project,Time to send,Čas odeslání
 DocType: Timesheet,Employee Detail,Detail zaměstnanec
@@ -5417,7 +5407,7 @@
 DocType: GL Entry,Is Advance,Je Zálohová
 apps/erpnext/erpnext/config/hr.py +202,Employee Lifecycle,Životní cyklus zaměstnanců
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinná
-apps/erpnext/erpnext/controllers/buying_controller.py +184,Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
+apps/erpnext/erpnext/controllers/buying_controller.py +196,Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
 DocType: Item,Default Purchase Unit of Measure,Výchozí nákupní měrná jednotka
 apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Poslední datum komunikace
 DocType: Clinical Procedure Item,Clinical Procedure Item,Položka klinické procedury
@@ -5458,7 +5448,7 @@
 DocType: Purchase Invoice Item,Total Weight,Celková váha
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +101,Commission on Sales,Provize z prodeje
 DocType: Job Offer Term,Value / Description,Hodnota / Popis
-apps/erpnext/erpnext/controllers/accounts_controller.py +697,"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 +706,"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
@@ -5470,7 +5460,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98,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}
 DocType: Asset Finance Book,Written Down Value,Psaná hodnota dolů
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +234,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 +235,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: Clinical Procedure,Age,Věk
 DocType: Sales Invoice Timesheet,Billing Amount,Fakturace Částka
 DocType: Cash Flow Mapping,Select Maximum Of 1,Vyberte možnost Maximálně 1
@@ -5482,7 +5472,7 @@
 DocType: Vehicle,Last Carbon Check,Poslední Carbon Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Legal Expenses,Výdaje na právní služby
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +147,Please select quantity on row ,Vyberte množství v řadě
-apps/erpnext/erpnext/config/accounts.py +315,Make Opening Sales and Purchase Invoices,Udělat počáteční prodejní a nákupní faktury
+apps/erpnext/erpnext/config/accounts.py +245,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/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +125,Telephone Expenses,Telefonní Náklady
@@ -5497,7 +5487,7 @@
 DocType: Maintenance Visit,Breakdown,Rozbor
 DocType: Travel Itinerary,Vegetarian,Vegetariánský
 DocType: Patient Encounter,Encounter Date,Datum setkání
-apps/erpnext/erpnext/controllers/accounts_controller.py +898,Account: {0} with currency: {1} can not be selected,Účet: {0} s měnou: {1} nelze vybrat
+apps/erpnext/erpnext/controllers/accounts_controller.py +907,Account: {0} with currency: {1} can not be selected,Účet: {0} s měnou: {1} nelze vybrat
 DocType: Bank Statement Transaction Settings Item,Bank Data,Bankovní údaje
 DocType: Purchase Receipt Item,Sample Quantity,Množství vzorku
 DocType: Bank Guarantee,Name of Beneficiary,Název příjemce
@@ -5506,19 +5496,19 @@
 DocType: Bank Reconciliation Detail,Cheque Date,Šek Datum
 apps/erpnext/erpnext/accounts/doctype/account/account.py +57,Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2}
 apps/erpnext/erpnext/setup/doctype/company/company.js +126,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 +39,As on Date,Stejně jako u Date
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +22,As on Date,Stejně jako u Date
 DocType: Additional Salary,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/operations/install_fixtures.py +103,Probation,Zkouška
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +78,Probation,Zkouška
 DocType: Program Enrollment Tool,New Academic Year,Nový akademický rok
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +866,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 +130,Total Paid Amount,Celkem uhrazené částky
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +137,Total Paid Amount,Celkem uhrazené částky
 DocType: GST Settings,B2C Limit,B2C Limit
 DocType: Job Card,Transferred Qty,Přenesená Množství
 apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigace
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +164,Planning,Plánování
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +141,Planning,Plánování
 DocType: Contract,Signee,Signee
 DocType: Share Balance,Issued,Vydáno
 DocType: Loan,Repayment Start Date,Datum zahájení splacení
@@ -5574,10 +5564,10 @@
 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/operations/install_fixtures.py +131,All Customer Groups,Všechny skupiny zákazníků
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +108,All Customer Groups,Všechny skupiny zákazníků
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +155,Accumulated Monthly,nahromaděné za měsíc
 DocType: Attendance Request,On Duty,Ve službě
-apps/erpnext/erpnext/controllers/accounts_controller.py +855,{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 +864,{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/hr/doctype/staffing_plan/staffing_plan.py +51,Staffing Plan {0} already exist for designation {1},Personální plán {0} již existuje pro označení {1}
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +46,Tax Template is mandatory.,Daňová šablona je povinné.
 apps/erpnext/erpnext/accounts/doctype/account/account.py +51,Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje
@@ -5585,22 +5575,22 @@
 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
-apps/erpnext/erpnext/config/accounts.py +50,To make Customer based incentive schemes.,Vytvoření pobídkových schémat založených na zákazníkovi.
+apps/erpnext/erpnext/config/accounts.py +550,To make Customer based incentive schemes.,Vytvoření pobídkových schémat založených na zákazníkovi.
 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ý
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +120,Customer LPO No.,Zákaznické číslo LPO
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +127,Customer LPO No.,Zákaznické číslo LPO
 DocType: Amazon MWS Settings,Market Place Account Group,Skupina účtů na trhu
 apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js +14,Make Payment Entries,Udělat položky platby
 DocType: Program,Courses,předměty
 DocType: Monthly Distribution Percentage,Percentage Allocation,Procento přidělení
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +116,Secretary,Sekretářka
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +91,Secretary,Sekretářka
 apps/erpnext/erpnext/regional/india/utils.py +177,House rented dates required for exemption calculation,"Dny pronajaté v domě, které jsou zapotřebí k výpočtu výjimky"
 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"
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +29,This action will stop future billing. Are you sure you want to cancel this subscription?,Tato akce zastaví budoucí fakturaci. Opravdu chcete zrušit tento odběr?
 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 +1387,Please set Company,Nastavte společnost
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js +406,Please set Company,Nastavte společnost
 DocType: Procedure Prescription,Procedure Created,Postup byl vytvořen
 DocType: Pricing Rule,Buying,Nákupy
 apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Nemoci a hnojiva
@@ -5611,18 +5601,18 @@
 ,Reqd By Date,Př p Podle data
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +147,Creditors,Věřitelé
 DocType: Assessment Plan,Assessment Name,Název Assessment
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +101,Show PDC in Print,Zobrazit PDC v tisku
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +107,Show PDC in Print,Zobrazit PDC v tisku
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +95,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
 DocType: Employee Onboarding,Job Offer,Nabídka práce
 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 +1156,Supplier Quotation,Dodavatel Nabídka
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1157,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 +169,Quantity ({0}) cannot be a fraction in row {1},Množství ({0}) nemůže být zlomek v řádku {1}
 DocType: Contract,Unsigned,Nepodepsaný
 DocType: Selling Settings,Each Transaction,Každé Transakce
-apps/erpnext/erpnext/stock/doctype/item/item.py +519,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 +523,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: Hotel Room,Extra Bed Capacity,Kapacita přistýlek
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +72,Varaiance ,Varaiance
@@ -5691,7 +5681,7 @@
 DocType: Account,Debit,Debet
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +63,Leaves must be allocated in multiples of 0.5,"Dovolené musí být přiděleny v násobcích 0,5"
 DocType: Work Order,Operation Cost,Provozní náklady
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +318,Identifying Decision Makers,Identifikace rozhodovacích orgánů
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +223,Identifying Decision Makers,Identifikace rozhodovacích orgánů
 apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,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]
@@ -5704,11 +5694,11 @@
 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/hr/doctype/employee/employee_dashboard.py +30,Lifecycle,Životní cyklus
 apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +142,Make BOM,Vytvořte kusovníku
-apps/erpnext/erpnext/controllers/selling_controller.py +158,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/controllers/selling_controller.py +161,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: Subscription,Taxes,Daně
 DocType: Purchase Invoice,capital goods,investiční majetek
 DocType: Purchase Invoice Item,Weight Per Unit,Hmotnost na jednotku
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +357,Paid and Not Delivered,Uhrazené a nedoručené
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +363,Paid and Not Delivered,Uhrazené a nedoručené
 DocType: QuickBooks Migrator,Default Cost Center,Výchozí Center Náklady
 apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Sklad Transakce
 DocType: Budget,Budget Accounts,rozpočtové účty
@@ -5721,7 +5711,7 @@
 DocType: Employee Advance,Due Advance Amount,Splatná částka předem
 DocType: Maintenance Visit,Customer Feedback,Zpětná vazba od zákazníků
 DocType: Account,Expense,Výdaj
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +42,Score cannot be greater than Maximum Score,Skóre nemůže být větší než maximum bodů
+apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +48,Score cannot be greater than Maximum Score,Skóre nemůže být větší než maximum bodů
 DocType: Support Search Source,Source Type,Typ zdroje
 apps/erpnext/erpnext/utilities/user_progress.py +129,Customers and Suppliers,Zákazníci a dodavatelé
 DocType: Item Attribute,From Range,Od Rozsah
@@ -5741,7 +5731,7 @@
 ,Employee Information,Informace o zaměstnanci
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +242,Healthcare Practitioner not available on {0},Lékař není k dispozici na {0}
 DocType: Stock Entry Detail,Additional Cost,Dodatečné náklady
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59,"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/accounts/report/general_ledger/general_ledger.py +57,"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 +975,Make Supplier Quotation,Vytvořit nabídku dodavatele
 DocType: Quality Inspection,Incoming,Přicházející
 apps/erpnext/erpnext/setup/doctype/company/company.js +90,Default tax templates for sales and purchase are created.,Výchozí daňové šablony pro prodej a nákup jsou vytvořeny.
@@ -5753,7 +5743,7 @@
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +68,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 +100,Row # {0}: Serial No {1} does not match with {2} {3},Řádek # {0}: Výrobní číslo {1} neodpovídá {2} {3}
 DocType: Stock Entry,Target Warehouse Address,Cílová adresa skladu
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +89,Casual Leave,Casual Leave
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +64,Casual Leave,Casual Leave
 DocType: Agriculture Task,End Day,Den konce
 DocType: Batch,Batch ID,Šarže ID
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +386,Note: {0},Poznámka: {0}
@@ -5780,7 +5770,7 @@
 DocType: Material Request,% Ordered,% objednáno
 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.
 DocType: Employee Grade,Employee Grade,Pracovní zařazení
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +106,Piecework,Úkolová práce
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +81,Piecework,Úkolová práce
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Avg. Buying Rate,Avg. Nákup Rate
 DocType: Share Balance,From No,Od č
 DocType: Task,Actual Time (in Hours),Skutečná doba (v hodinách)
@@ -5795,7 +5785,7 @@
 DocType: Share Balance,Is Company,Je společnost
 DocType: Stock Ledger Entry,Stock Ledger Entry,Reklamní Ledger Entry
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +190,{0} on Half day Leave on {1},{0} v půldenní dovolené na {1}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +88,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 +87,Same item has been entered multiple times,Stejný bod byl zadán vícekrát
 DocType: Department,Leave Block List,Nechte Block List
 DocType: Purchase Invoice,Tax ID,DIČ
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,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ý
@@ -5812,12 +5802,12 @@
 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;"
 apps/erpnext/erpnext/hr/utils.py +152,To date can not be less than from date,K dnešnímu dni nemůže být méně než od data
 DocType: Opportunity,To Discuss,K projednání
-apps/erpnext/erpnext/stock/stock_ledger.py +378,{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 +382,{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í
 DocType: Support Settings,Forum URL,Adresa URL fóra
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +75,Temporary Accounts,Dočasné Účty
 apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +40,Source Location is required for the asset {0},Místo zdroje je požadováno pro daný účet {0}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Black,Černá
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +159,Black,Černá
 DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Item
 DocType: Shareholder,Contact List,Seznam kontaktů
 DocType: Account,Auditor,Auditor
@@ -5835,12 +5825,12 @@
 DocType: Leave Type,Maximum Continuous Days Applicable,Maximální počet nepřetržitých dnů
 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 +118,"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/accounts/report/accounts_receivable/accounts_receivable.html +90,Cheques Required,Potřebné kontroly
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +93,Cheques Required,Potřebné kontroly
 DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku)
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Absent
 DocType: Job Applicant Source,Job Applicant Source,Zdroj žádosti o zaměstnání
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +328,IGST Amount,IGST částka
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Nepodařilo se nastavit firmu
+apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +41,Failed to setup company,Nepodařilo se nastavit firmu
 DocType: Asset Repair,Asset Repair,Opravy aktiv
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +155,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
@@ -5886,7 +5876,7 @@
 DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
 apps/erpnext/erpnext/accounts/page/pos/pos.js +906,Submitted orders can not be deleted,Předložené objednávky nelze smazat
 apps/erpnext/erpnext/accounts/doctype/account/account.py +121,"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 +360,Quality Management,Řízení kvality
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +391,Quality Management,Řízení kvality
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +52,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
@@ -5909,14 +5899,14 @@
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +19,Restart Subscription,Restartujte předplatné
 DocType: Linked Plant Analysis,Linked Plant Analysis,Analýza propojených rostlin
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +358,Transporter ID,ID přepravce
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +317,Value Proposition,Návrh hodnoty
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +222,Value Proposition,Návrh hodnoty
 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"
 DocType: Purchase Invoice Item,Service End Date,Datum ukončení služby
 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: Bank Guarantee,Receiving,Příjem
 DocType: Training Event Employee,Invited,Pozván
-apps/erpnext/erpnext/config/accounts.py +346,Setup Gateway accounts.,Nastavení brány účty.
+apps/erpnext/erpnext/config/accounts.py +276,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 +43,Fixed Assets,Dlouhodobý majetek
 DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange zisk / ztráta
@@ -5940,13 +5930,13 @@
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Existuje Náklady Výchozí aktivity pro Typ aktivity - {0}
 DocType: Work Order,Planned Operating Cost,Plánované provozní náklady
 DocType: Academic Term,Term Start Date,Termín Datum zahájení
-apps/erpnext/erpnext/config/accounts.py +515,List of all share transactions,Seznam všech transakcí s akciemi
+apps/erpnext/erpnext/config/accounts.py +440,List of all share transactions,Seznam všech transakcí s akciemi
 DocType: Supplier,Is Transporter,Je Transporter
 DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,"Import faktury z Shopify, pokud je platba označena"
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +218,Both Trial Period Start Date and Trial Period End Date must be set,Musí být nastaven datum zahájení zkušebního období a datum ukončení zkušebního období
 apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Průměrné hodnocení
-apps/erpnext/erpnext/controllers/accounts_controller.py +799,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/controllers/accounts_controller.py +808,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
 DocType: Subscription Plan Detail,Plan,Plán
 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
@@ -5985,7 +5975,7 @@
 DocType: Workstation,per hour,za hodinu
 DocType: Blanket Order,Purchasing,Nákup
 DocType: Announcement,Announcement,Oznámení
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +129,Customer LPO,Zákazník LPO
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +130,Customer LPO,Zákazník LPO
 DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",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."
 apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Distribuce
@@ -5993,20 +5983,20 @@
 DocType: Expense Claim Advance,Expense Claim Advance,Nároky na úhradu nákladů
 DocType: Lab Test,Report Preference,Předvolba reportu
 apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Informace o dobrovolnictví.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +121,Project Manager,Project Manager
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +96,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/operations/install_fixtures.py +356,Dispatch,Odeslání
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +387,Dispatch,Odeslání
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +75,Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +191,Net Asset value as on,Čistá hodnota aktiv i na
 DocType: Crop,Produce,Vyrobit
 DocType: Hotel Settings,Default Taxes and Charges,Výchozí Daně a poplatky
 DocType: Account,Receivable,Pohledávky
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +321,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 +325,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Řádek # {0}: Není povoleno měnit dodavatele, objednávky již existuje"
 DocType: Stock Entry,Material Consumption for Manufacture,Spotřeba materiálu pro výrobu
 DocType: Item Alternative,Alternative Item Code,Alternativní kód položky
 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 +1067,Select Items to Manufacture,Vyberte položky do Výroba
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1068,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 +974,"Master data syncing, it might take some time","Kmenová data synchronizace, může to trvat nějaký čas"
 DocType: Item,Material Issue,Material Issue
@@ -6070,7 +6060,7 @@
 DocType: Production Plan,Include Subcontracted Items,Zahrnout subdodávané položky
 apps/erpnext/erpnext/projects/doctype/project/project.py +281,Join,Připojit
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +81,Shortage Qty,Nedostatek Množství
-apps/erpnext/erpnext/stock/doctype/item/item.py +788,Item variant {0} exists with same attributes,Bod varianta {0} existuje s stejné atributy
+apps/erpnext/erpnext/stock/doctype/item/item.py +792,Item variant {0} exists with same attributes,Bod varianta {0} existuje s stejné atributy
 DocType: Loan,Repay from Salary,Splatit z platu
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +405,Requesting payment against {0} {1} for amount {2},Požadovala vyplacení proti {0} {1} na částku {2}
 DocType: Additional Salary,Salary Slip,Výplatní páska
@@ -6098,7 +6088,7 @@
 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 +53,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 +1241,It is needed to fetch Item Details.,"Je třeba, aby přinesla Detaily položky."
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1247,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: Cash Flow Mapping Accounts,Account,Účet
@@ -6114,7 +6104,7 @@
 apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potenciální příležitosti pro prodej.
 DocType: Shareholder,Folio no.,Číslo folia
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +251,Invalid {0},Neplatný {0}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +93,Sick Leave,Zdravotní dovolená
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,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/data/industry_type.py +22,Department Stores,Obchodní domy
@@ -6140,7 +6130,7 @@
 DocType: Purchase Invoice Item,Service Stop Date,Datum ukončení služby
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Částka poslední objednávky
 DocType: Cash Flow Mapper,e.g Adjustments for:,např. Úpravy pro:
-apps/erpnext/erpnext/stock/doctype/item/item.py +300," {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"
+apps/erpnext/erpnext/stock/doctype/item/item.py +304," {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: Certification Application,Yet to appear,Přesto se objeví
 DocType: Delivery Stop,Email Sent To,E-mailem odeslaným
@@ -6155,14 +6145,14 @@
 DocType: Subscription Plan,Payment Plan,Platebni plan
 DocType: Shopping Cart Settings,Enable purchase of items via the website,Aktivujte nákup položek prostřednictvím webové stránky
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +296,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/config/accounts.py +532,Subscription Management,Řízení předplatného
+apps/erpnext/erpnext/config/accounts.py +561,Subscription Management,Řízení předplatného
 DocType: Appraisal,Appraisal Template,Posouzení Template
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +255,To Pin Code,K označení kódu
 DocType: Soil Texture,Ternary Plot,Ternary Plot
 DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,"Zaškrtněte toto, chcete-li zapnout naplánovaný program Denní synchronizace prostřednictvím plánovače"
 DocType: Item Group,Item Classification,Položka Klasifikace
 DocType: Driver,License Number,Číslo licence
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Business Development Manager,Business Development Manager
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +94,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: Crop,Period,Období
@@ -6189,7 +6179,7 @@
 DocType: Certification Application,Name of Applicant,Jméno žadatele
 apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Čas list pro výrobu.
 apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,mezisoučet
-apps/erpnext/erpnext/stock/doctype/item/item.py +727,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Vlastnosti Variantu nelze změnit po transakci akcií. Budete muset vytvořit novou položku, abyste to udělali."
+apps/erpnext/erpnext/stock/doctype/item/item.py +731,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,"Vlastnosti Variantu nelze změnit po transakci akcií. Budete muset vytvořit novou položku, abyste to udělali."
 apps/erpnext/erpnext/config/integrations.py +18,GoCardless SEPA Mandate,GoCardless SEPA mandát
 DocType: Healthcare Practitioner,Charges,Poplatky
 DocType: Production Plan,Get Items For Work Order,Získat položky pro pracovní objednávku
@@ -6201,7 +6191,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`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 +48,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."
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1549,Healthcare Services,Zdravotnické služby
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1553,Healthcare Services,Zdravotnické služby
 ,Project wise Stock Tracking,Sledování zboží dle projektu
 DocType: GST HSN Code,Regional,Regionální
 apps/erpnext/erpnext/config/healthcare.py +50,Laboratory,Laboratoř
@@ -6210,7 +6200,7 @@
 DocType: Item Customer Detail,Ref Code,Ref Code
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Zákaznická skupina je vyžadována v POS profilu
 DocType: HR Settings,Payroll Settings,Nastavení Mzdové
-apps/erpnext/erpnext/config/accounts.py +169,Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
+apps/erpnext/erpnext/config/accounts.py +142,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
@@ -6236,7 +6226,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/account.py +53,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ů
-apps/erpnext/erpnext/public/js/controllers/transaction.js +879,Service Stop Date cannot be after Service End Date,Datum ukončení služby nemůže být po datu ukončení služby
+apps/erpnext/erpnext/public/js/controllers/transaction.js +885,Service Stop Date cannot be after Service End Date,Datum ukončení služby nemůže být po datu ukončení služby
 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
@@ -6248,7 +6238,7 @@
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Hodiny
 DocType: Project,Expected Start Date,Očekávané datum zahájení
 DocType: Purchase Invoice,04-Correction in Invoice,04 - oprava faktury
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1040,Work Order already created for all items with BOM,Pracovní zakázka již vytvořena pro všechny položky s kusovníkem
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Work Order already created for all items with BOM,Pracovní zakázka již vytvořena pro všechny položky s kusovníkem
 DocType: Payment Request,Party Details,Party Podrobnosti
 apps/erpnext/erpnext/stock/doctype/item/item.js +62,Variant Details Report,Zpráva Variant Podrobnosti
 DocType: Setup Progress Action,Setup Progress Action,Pokročilé nastavení
@@ -6270,11 +6260,11 @@
 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 +537,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 +541,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/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,CWIP Account,CWIP účet
 apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Trénink Feedback
-apps/erpnext/erpnext/config/accounts.py +211,Tax Withholding rates to be applied on transactions.,"Sazby daně ze zadržených daní, které se použijí na transakce."
+apps/erpnext/erpnext/config/accounts.py +184,Tax Withholding rates to be applied on transactions.,"Sazby daně ze zadržených daní, které se použijí na transakce."
 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}"
 DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-
@@ -6308,7 +6298,7 @@
 DocType: Purchase Invoice Item,Amount (Company Currency),Částka (Měna Společnosti)
 DocType: Agriculture Analysis Criteria,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 +382,{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 +386,{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/healthcare/doctype/clinical_procedure/clinical_procedure.js +98,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,Postup uskutečnění kvantity skladování není k dispozici ve skladu. Chcete zaznamenat převod akcií
@@ -6319,7 +6309,7 @@
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +79,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: Asset,Custodian,Depozitář
-apps/erpnext/erpnext/config/accounts.py +356,Point-of-Sale Profile,Point-of-Sale Profil
+apps/erpnext/erpnext/config/accounts.py +543,Point-of-Sale Profile,Point-of-Sale Profil
 apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25,{0} should be a value between 0 and 100,{0} by měla být hodnota mezi 0 a 100
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +323,Payment of {0} from {1} to {2},Platba {0} od {1} do {2}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Unsecured Loans,Nezajištěných úvěrů
@@ -6352,10 +6342,10 @@
 DocType: Item,Has Serial No,Má Sériové číslo
 DocType: Employee,Date of Issue,Datum vydání
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +252,"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 +174,Row #{0}: Set Supplier for item {1},Řádek # {0}: Nastavte Dodavatel pro položku {1}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +173,Row #{0}: Set Supplier for item {1},Řádek # {0}: Nastavte Dodavatel pro položku {1}
 DocType: Global Defaults,Default Distance Unit,Výchozí jednotka vzdálenosti
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,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 +220,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 +224,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
 DocType: Asset,Assets,Aktiva
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Počítač
@@ -6384,7 +6374,7 @@
 ,Average Commission Rate,Průměrná cena Komise
 DocType: Share Balance,No of Shares,Počet akcií
 DocType: Taxable Salary Slab,To Amount,Do výše
-apps/erpnext/erpnext/stock/doctype/item/item.py +475,'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 +479,'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 +59,Select Status,Vyberte možnost Stav
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +44,Attendance can not be marked for future dates,Účast nemůže být označen pro budoucí data
 DocType: Support Search Source,Post Description Key,Tlačítko Popis příspěvku
@@ -6394,7 +6384,7 @@
 DocType: Opportunity,Sales Stage,Prodejní fáze
 DocType: Purchase Taxes and Charges,Account Head,Účet Head
 DocType: Company,HRA Component,Součást HRA
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +142,Electrical,Elektrický
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,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)
 DocType: Grant Application,Requested Amount,Požadovaná částka
@@ -6427,7 +6417,7 @@
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +407,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: Production Plan Item,Ordered Qty,Objednáno Množství
-apps/erpnext/erpnext/stock/doctype/item/item.py +818,Item {0} is disabled,Položka {0} je zakázána
+apps/erpnext/erpnext/stock/doctype/item/item.py +822,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 +1021,BOM does not contain any stock item,BOM neobsahuje žádnou skladovou položku
 DocType: Chapter,Chapter Head,Hlava kapitoly
@@ -6450,7 +6440,7 @@
 DocType: Sales Invoice Timesheet,Billing Hours,Billing Hodiny
 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 +529,Default BOM for {0} not found,Výchozí BOM pro {0} nebyl nalezen
-apps/erpnext/erpnext/stock/doctype/item/item.py +541,Row #{0}: Please set reorder quantity,Řádek # {0}: Prosím nastavte množství objednací
+apps/erpnext/erpnext/stock/doctype/item/item.py +545,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: Share Transfer,To Folio No,Do složky Folio č
@@ -6486,14 +6476,14 @@
 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 +645,BOM and Manufacturing Quantity are required,BOM a výroba množství jsou povinné
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +62,Ageing Range 2,Stárnutí rozsah 2
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +648,BOM and Manufacturing Quantity are required,BOM a výroba množství jsou povinné
+apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +35,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/setup/setup_wizard/setup_wizard.py +29,Installing presets,Instalace předvoleb
 DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +113,No Delivery Note selected for Customer {},Pro zákazníka nebyl vybrán žádný zákazník {}
 apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py +17,Employee {0} has no maximum benefit amount,Zaměstnanec {0} nemá maximální částku prospěchu
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1210,Select Items based on Delivery Date,Vyberte položky podle data doručení
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1211,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 +127,Available {0},K dispozici {0}
@@ -6516,7 +6506,7 @@
 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
 DocType: Hotel Room Reservation,Hotel Room Reservation,Rezervace pokojů v hotelu
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +357,Customer Service,Služby zákazníkům
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +388,Customer Service,Služby zákazníkům
 DocType: BOM,Thumbnail,Thumbnail
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +383,No contacts with email IDs found.,Nebyly nalezeny žádné kontakty s identifikátory e-mailu.
 DocType: Item Customer Detail,Item Customer Detail,Položka Detail Zákazník
@@ -6528,7 +6518,7 @@
 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/healthcare/doctype/practitioner_schedule/practitioner_schedule.js +83,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?","Plán pro překrytí {0}, chcete pokračovat po přeskočení přesahovaných slotů?"
-apps/erpnext/erpnext/config/accounts.py +326,Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
+apps/erpnext/erpnext/config/accounts.py +256,Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
 apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js +8,Grant Leaves,Grantové listy
 DocType: Restaurant,Default Tax Template,Výchozí daňová šablona
 apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +71,{0} Students have been enrolled,{0} Studenti byli zapsáni
@@ -6545,7 +6535,7 @@
 DocType: Task,Closing Date,Uzávěrka Datum
 DocType: Sales Order Item,Produced Quantity,Produkoval Množství
 DocType: Item Price,Quantity  that must be bought or sold per UOM,"Množství, které musí být zakoupeno nebo prodané podle UOM"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Engineer,Inženýr
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +89,Engineer,Inženýr
 DocType: Employee Tax Exemption Category,Max Amount,Maximální částka
 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
@@ -6569,7 +6559,7 @@
 DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Nakupujte daňový / lodní titul
 apps/erpnext/erpnext/projects/doctype/project/project.js +54,Gantt Chart,Pruhový diagram
 DocType: Crop Cycle,Cycle Type,Typ cyklu
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +102,Part-time,Part-time
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +77,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ů
@@ -6597,7 +6587,7 @@
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +60,Available for use date is required,K dispozici je datum k dispozici pro použití
 DocType: Request for Quotation,Supplier Detail,dodavatel Detail
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +181,Error in formula or condition: {0},Chyba ve vzorci nebo stavu: {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +112,Invoiced Amount,Fakturovaná částka
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119,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%
 apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Účast
 apps/erpnext/erpnext/public/js/pos/pos.html +115,Stock Items,sklade
@@ -6620,7 +6610,7 @@
 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
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1750,Please select Healthcare Service,Vyberte prosím službu zdravotní péče
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1754,Please select Healthcare Service,Vyberte prosím službu zdravotní péče
 DocType: Purchase Taxes and Charges,On Net Total,On Net Celkem
 apps/erpnext/erpnext/controllers/item_variant.py +92,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}
 DocType: Restaurant Reservation,Waitlisted,Vyčkejte
@@ -6638,7 +6628,7 @@
 DocType: Purchase Invoice,Contact Email,Kontaktní e-mail
 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/operations/install_fixtures.py +222,Notice Period,Výpovědní Lhůta
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,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
@@ -6661,7 +6651,7 @@
 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
 DocType: Company,Company Logo,Logo společnosti
-apps/erpnext/erpnext/stock/doctype/item/item.py +783,Please specify Attribute Value for attribute {0},Uveďte prosím atributu Hodnota atributu {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +787,Please specify Attribute Value for attribute {0},Uveďte prosím atributu Hodnota atributu {0}
 DocType: QuickBooks Migrator,Default Warehouse,Výchozí sklad
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +55,Budget cannot be assigned against Group Account {0},Rozpočet nemůže být přiřazena na skupinový účet {0}
 DocType: Shopping Cart Settings,Show Price,Zobrazit cenu
@@ -6675,7 +6665,7 @@
 DocType: Appraisal,Total Score (Out of 5),Celkové skóre (Out of 5)
 DocType: Student Attendance Tool,Batch,Šarže
 DocType: Support Search Source,Query Route String,Dotaz řetězce trasy
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1172,Update rate as per last purchase,Míra aktualizace podle posledního nákupu
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1173,Update rate as per last purchase,Míra aktualizace podle posledního nákupu
 DocType: Donor,Donor Type,Typ dárce
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +710,Auto repeat document updated,Dokument byl aktualizován automaticky
 apps/erpnext/erpnext/stock/doctype/item/item.js +29,Balance,Zůstatek
@@ -6691,7 +6681,7 @@
 DocType: Assessment Result,Total Score,Celkové skóre
 DocType: Crop Cycle,ISO 8601 standard,Norma ISO 8601
 DocType: Journal Entry,Debit Note,Debit Note
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1513,You can only redeem max {0} points in this order.,V tomto pořadí můžete uplatnit max. {0} body.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1517,You can only redeem max {0} points in this order.,V tomto pořadí můžete uplatnit max. {0} body.
 DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.RRRR.-
 apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py +102,Please enter API Consumer Secret,Zadejte zákaznické tajemství API
 DocType: Stock Entry,As per Stock UOM,Podle Stock nerozpuštěných
@@ -6704,11 +6694,11 @@
 DocType: Journal Entry,Total Debit,Celkem Debit
 DocType: Travel Request Costing,Sponsored Amount,Sponzorovaná částka
 DocType: Manufacturing Settings,Default Finished Goods Warehouse,Výchozí sklad hotových výrobků
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +316,Please select Patient,Vyberte pacienta
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +380,Please select Patient,Vyberte pacienta
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Sales Person,Prodej Osoba
 DocType: Hotel Room Package,Amenities,Vybavení
 DocType: QuickBooks Migrator,Undeposited Funds Account,Účet neukladaných prostředků
-apps/erpnext/erpnext/config/accounts.py +271,Budget and Cost Center,Rozpočet a nákladového střediska
+apps/erpnext/erpnext/config/accounts.py +201,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
 DocType: Sales Invoice,Loyalty Points Redemption,Věrnostní body Vykoupení
 ,Appointment Analytics,Aplikace Analytics
@@ -6771,7 +6761,7 @@
 DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Položka objednávky restaurace
 DocType: Purchase Invoice,Rounded Total (Company Currency),Celkem zaokrouhleno (měna solečnosti)
 apps/erpnext/erpnext/accounts/doctype/account/account.py +103,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 +272,{0} {1} has been modified. Please refresh.,{0} {1} byl změněn. Prosím aktualizujte.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +276,{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.
 apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js +24,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.",Při neomezeném uplynutí platnosti věrnostních bodů nechte dobu trvání platnosti prázdné nebo 0.
 DocType: Asset Maintenance Team,Maintenance Team Members,Členové týmu údržby
@@ -6795,7 +6785,7 @@
 apps/erpnext/erpnext/accounts/party.py +30,{0}: {1} does not exists,{0}: {1} neexistuje
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +78,Select Batch Numbers,Zvolte čísla šarží
 apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py +231,To GSTIN,Na GSTIN
-apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Směnky vznesené zákazníkům.
+apps/erpnext/erpnext/config/accounts.py +14,Bills raised to Customers.,Směnky vznesené zákazníkům.
 DocType: Healthcare Settings,Invoice Appointments Automatically,Fakturační schůzky automaticky
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID projektu
 DocType: Salary Component,Variable Based On Taxable Salary,Proměnná založená na zdanitelném platu
@@ -6836,7 +6826,7 @@
 apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js +30,This is a root healthcare service unit and cannot be edited.,Jedná se o základní službu zdravotnické služby a nelze ji editovat.
 DocType: Asset Repair,Repair Status,Stav opravy
 apps/erpnext/erpnext/public/js/event.js +31,Add Sales Partners,Přidat obchodní partnery
-apps/erpnext/erpnext/config/accounts.py +84,Accounting journal entries.,Zápisy v účetním deníku.
+apps/erpnext/erpnext/config/accounts.py +45,Accounting journal entries.,Zápisy v účetním deníku.
 DocType: Travel Request,Travel Request,Žádost o cestování
 DocType: Delivery Note Item,Available Qty at From Warehouse,K dispozici Množství na Od Warehouse
 apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py +17,Please select Employee Record first.,"Prosím, vyberte zaměstnance záznam první."
@@ -6870,10 +6860,9 @@
 DocType: Company,Default Deferred Revenue Account,Výchozí účet odloženého výnosu
 DocType: Project,Second Email,Druhý e-mail
 DocType: Budget,Action if Annual Budget Exceeded on Actual,"Akce, pokud je roční rozpočet překročen na skutečné"
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +127,Not Available,Není k dispozici
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +129,Not Available,Není k dispozici
 DocType: Pricing Rule,Min Qty,Min Množství
 apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js +41,Disable Template,Zakázat šablonu
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +105,Please select Healthcare Practitioner and Date,Zvolte lékaře a datum
 DocType: Bank Statement Transaction Invoice Item,Transaction Date,Transakce Datum
 DocType: Production Plan Item,Planned Qty,Plánované Množství
 DocType: Company,Date of Incorporation,Datum začlenění
@@ -6913,7 +6902,7 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +21,"Cannot Submit, Employees left to mark attendance","Nelze odeslat, Zaměstnanci odešli, aby označili účast"
 DocType: Inpatient Record,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 +295,"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
+apps/erpnext/erpnext/config/accounts.py +225,"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 +163,"Item {0} is a template, please select one of its variants","Položka {0} je šablona, prosím vyberte jednu z jeho variant"
 DocType: Purchase Invoice Item,Deferred Expense,Odložený výdaj
@@ -6923,10 +6912,10 @@
 DocType: Purchase Order,Advance Paid,Vyplacené zálohy
 DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,Procento nadvýroby pro objednávku prodeje
 DocType: Item,Item Tax,Daň Položky
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +950,Material to Supplier,Materiál Dodavateli
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +951,Material to Supplier,Materiál Dodavateli
 DocType: Soil Texture,Loamy Sand,Loamy Sand
 DocType: Production Plan,Material Request Planning,Plánování požadavků na materiál
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +705,Excise Invoice,Spotřební Faktura
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +708,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
@@ -6943,7 +6932,7 @@
 apps/erpnext/erpnext/setup/default_success_action.py +13,{0} has been submitted successfully,{0} byla úspěšně odeslána
 DocType: Loan,Loan Type,Typ úvěru
 DocType: Scheduling Tool,Scheduling Tool,Plánování Tool
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +156,Credit Card,Kreditní karta
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Credit Card,Kreditní karta
 DocType: BOM,Item to be manufactured or repacked,Položka k výrobě nebo zabalení
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +766,Syntax error in condition: {0},Chyba syntaxe ve stavu: {0}
 DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
@@ -6974,7 +6963,7 @@
 DocType: Travel Itinerary,Preferred Area for Lodging,Preferovaná oblast pro ubytování
 apps/erpnext/erpnext/config/selling.py +184,Analytics,analytika
 apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Košík je prázdný
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +424,"Item {0} has no Serial No. Only serilialized items \
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +430,"Item {0} has no Serial No. Only serilialized items \
 						can have delivery based on Serial No",Položka {0} nemá žádné sériové číslo. Serializované položky \ mohou být doručeny na základě sériového čísla
 DocType: Vehicle,Model,Model
 DocType: Work Order,Actual Operating Cost,Skutečné provozní náklady
@@ -6998,7 +6987,7 @@
 DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Po dokončení platby přesměrovat uživatele na vybrané stránky.
 DocType: Company,Existing Company,stávající Company
 DocType: Healthcare Settings,Result Emailed,Výsledkem byl emailem
-apps/erpnext/erpnext/controllers/buying_controller.py +99,"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/controllers/buying_controller.py +101,"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/hr/doctype/leave_period/leave_period.py +35,To date can not be equal or less than from date,K dnešnímu dni nemůže být stejná nebo menší než od data
 apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js +118,Nothing to change,Nic se nemění
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +104,Please select a csv file,Vyberte soubor csv
@@ -7007,10 +6996,10 @@
 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/controllers/buying_controller.py +679,Row #{0}: Reqd by Date cannot be before Transaction Date,Řádek # {0}: Reqd by Date nemůže být před datem transakce
+apps/erpnext/erpnext/controllers/buying_controller.py +691,Row #{0}: Reqd by Date cannot be before Transaction Date,Řádek # {0}: Reqd by Date nemůže být před datem transakce
 apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,představované výrobky
 apps/erpnext/erpnext/assets/doctype/asset/asset.js +384,Select Serial No,Zvolte pořadové číslo
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Designer,Návrhář
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Designer,Návrhář
 apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Podmínky Template
 DocType: Delivery Trip,Delivery Details,Zasílání
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +618,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}
@@ -7036,7 +7025,7 @@
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Dodací lhůta dny
 DocType: Cash Flow Mapping,Is Income Tax Expense,Jsou náklady na daň z příjmů
 apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py +19,Your order is out for delivery!,Vaše objednávka je k dodání!
-apps/erpnext/erpnext/controllers/accounts_controller.py +684,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 +693,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"
 ,Stock Summary,Sklad Souhrn
