diff --git a/erpnext/translations/cs.csv b/erpnext/translations/cs.csv
index 4dd1fd6..a85bafe 100644
--- a/erpnext/translations/cs.csv
+++ b/erpnext/translations/cs.csv
@@ -88,7 +88,7 @@
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +185,Sort by Price,Seřadit podle ceny
 apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Service Expense
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +893,Serial Number: {0} is already referenced in Sales Invoice: {1},Sériové číslo: {0} je již uvedeno v prodejní faktuře: {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Invoice,Faktura
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +878,Invoice,Faktura
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +109,Make Retention Stock Entry,Zadejte retenční položku
 DocType: Purchase Invoice Item,Item Weight Details,Položka podrobnosti o hmotnosti
 DocType: Asset Maintenance Log,Periodicity,Periodicita
@@ -98,9 +98,8 @@
 DocType: Salary Component,Abbr,Zkr
 DocType: Appraisal Goal,Score (0-5),Score (0-5)
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +223,Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} se neshoduje s {3}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +75,Row # {0}:,Řádek č. {0}:
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77,Row # {0}:,Řádek č. {0}:
 DocType: Timesheet,Total Costing Amount,Celková kalkulace Částka
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Skupina zákazníků&gt; Území
 DocType: Delivery Note,Vehicle No,Vozidle
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +160,Please select Price List,"Prosím, vyberte Ceník"
 DocType: Accounts Settings,Currency Exchange Settings,Nastavení směnného kurzu
@@ -139,7 +138,7 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Odkaz: {0}, kód položky: {1} a zákazník: {2}"
 apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,Kg
 apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Otevření o zaměstnání.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +103,BOM is not specified for subcontracting item {0} at row {1},Kusovník není zadán pro subdodavatelskou položku {0} na řádku {1}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +104,BOM is not specified for subcontracting item {0} at row {1},Kusovník není zadán pro subdodavatelskou položku {0} na řádku {1}
 apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Výsledek byl předložen
 DocType: Item Attribute,Increment,Přírůstek
 apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +61,Timespan,Časové rozpětí
@@ -179,7 +178,7 @@
 DocType: Delivery Trip,Departure Time,Čas odjezdu
 DocType: Vehicle Service,Brake Oil,Brake Oil
 DocType: Tax Rule,Tax Type,Daňové Type
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +561,Taxable Amount,Zdanitelná částka
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +568,Taxable Amount,Zdanitelná částka
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
 DocType: BOM,Item Image (if not slideshow),Item Image (ne-li slideshow)
 DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hodinová sazba / 60) * Skutečný čas operace
@@ -193,8 +192,8 @@
 DocType: Quality Inspection,Get Specification Details,Získat Specifikace Podrobnosti
 apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Šablony dodavatelů.
 DocType: Lead,Interested,Zájemci
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +219,Opening,Otvor
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +29,From {0} to {1},Od {0} do {1}
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +226,Opening,Otvor
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +30,From {0} to {1},Od {0} do {1}
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Nepodařilo se nastavit daně
 DocType: Item,Copy From Item Group,Kopírovat z bodu Group
 DocType: Delivery Trip,Delivery Notification,Oznámení o doručení
@@ -202,7 +201,7 @@
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Účet Pay Pouze
 DocType: Employee Loan,Repay Over Number of Periods,Splatit Over počet období
 DocType: Stock Entry,Additional Costs,Dodatečné náklady
-apps/erpnext/erpnext/accounts/doctype/account/account.py +140,Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +138,Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.
 DocType: Lead,Product Enquiry,Dotaz Product
 DocType: Education Settings,Validate Batch for Students in Student Group,Ověřit dávku pro studenty ve skupině studentů
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Žádný záznam volno nalezených pro zaměstnance {0} na {1}
@@ -219,7 +218,7 @@
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Výpis z účtu
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Farmaceutické
 DocType: Purchase Invoice Item,Is Fixed Asset,Je dlouhodobý majetek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +251,"Available qty is {0}, you need {1}","K dispozici je množství {0}, musíte {1}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +256,"Available qty is {0}, you need {1}","K dispozici je množství {0}, musíte {1}"
 DocType: Expense Claim Detail,Claim Amount,Nárok Částka
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Duplicitní skupinu zákazníků uvedeny v tabulce na knihy zákazníků skupiny
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Dodavatel Typ / dovozce
@@ -242,7 +241,7 @@
 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 +380,{0} {1} is frozen,{0} {1} je zmrazený
-apps/erpnext/erpnext/setup/doctype/company/company.py +129,Please select Existing Company for creating Chart of Accounts,Vyberte existující společnosti pro vytváření účtový rozvrh
+apps/erpnext/erpnext/setup/doctype/company/company.py +136,Please select Existing Company for creating Chart of Accounts,Vyberte existující společnosti pro vytváření účtový rozvrh
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Stock Náklady
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Vyberte objekt Target Warehouse
 apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,"Prosím, zadejte Preferred Kontakt e-mail"
@@ -252,20 +251,21 @@
 DocType: Delivery Note,Installation Status,Stav instalace
 apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
 					<br>Absent: {1}",Chcete aktualizovat docházku? <br> Present: {0} \ <br> Chybí: {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +326,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +344,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0}
 DocType: Request for Quotation,RFQ-,RFQ-
 DocType: Item,Supply Raw Materials for Purchase,Dodávky suroviny pro nákup
 DocType: Agriculture Analysis Criteria,Fertilizer,Hnojivo
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +150,At least one mode of payment is required for POS invoice.,pro POS fakturu je nutná alespoň jeden způsob platby.
 DocType: Products Settings,Show Products as a List,Zobrazit produkty jako seznam
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +507,Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +512,Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
 DocType: Student Admission Program,Minimum Age,Minimální věk
 apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Příklad: Základní Mathematics
-apps/erpnext/erpnext/controllers/accounts_controller.py +769,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Chcete-li zahrnout daně na řádku v poměru Položka {0}, daně v řádcích {1} musí být zahrnuty"
+apps/erpnext/erpnext/controllers/accounts_controller.py +780,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Chcete-li zahrnout daně na řádku v poměru Položka {0}, daně v řádcích {1} musí být zahrnuty"
 apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Nastavení pro HR modul
 DocType: SMS Center,SMS Center,SMS centrum
 DocType: Sales Invoice,Change Amount,změna Částka
 DocType: BOM Update Tool,New BOM,Nový BOM
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Zobrazit pouze POS
 DocType: Driver,Driving License Categories,Kategorie řidičských oprávnění
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Zadejte prosím datum doručení
 DocType: Depreciation Schedule,Make Depreciation Entry,Udělat Odpisy Entry
@@ -303,13 +303,13 @@
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,limitu
 DocType: Production Planning Tool,Sales Orders,Prodejní objednávky
 DocType: Purchase Taxes and Charges,Valuation,Ocenění
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +373,Set as Default,Nastavit jako výchozí
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +380,Set as Default,Nastavit jako výchozí
 ,Purchase Order Trends,Nákupní objednávka trendy
 apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Přejděte na položku Zákazníci
 apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Žádost o cenovou nabídku lze přistupovat kliknutím na následující odkaz
 apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Přidělit listy za rok.
 DocType: SG Creation Tool Course,SG Creation Tool Course,SG nástroj pro tvorbu hřiště
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,Insufficient Stock,nedostatečná Sklad
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +258,Insufficient Stock,nedostatečná Sklad
 DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Zakázat Plánování kapacit a Time Tracking
 DocType: Email Digest,New Sales Orders,Nové Prodejní objednávky
 DocType: Bank Guarantee,Bank Account,Bankovní účet
@@ -389,10 +389,10 @@
 DocType: Student Admission,Student Admission,Student Vstupné
 ,Terretory,Terretory
 apps/erpnext/erpnext/stock/doctype/item/item.py +729,Item {0} is cancelled,Položka {0} je zrušen
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Material Request,Požadavek na materiál
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +952,Material Request,Požadavek na materiál
 DocType: Bank Reconciliation,Update Clearance Date,Aktualizace Výprodej Datum
 DocType: Item,Purchase Details,Nákup Podrobnosti
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +382,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebyl nalezen v &quot;suroviny dodané&quot; tabulky v objednávce {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +387,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebyl nalezen v &quot;suroviny dodané&quot; tabulky v objednávce {1}
 DocType: Salary Slip,Total Principal Amount,Celková hlavní částka
 DocType: Student Guardian,Relation,Vztah
 DocType: Student Guardian,Mother,Matka
@@ -430,7 +430,7 @@
 DocType: Asset,Next Depreciation Date,Vedle Odpisy Datum
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Náklady na činnost na jednoho zaměstnance
 DocType: Accounts Settings,Settings for Accounts,Nastavení účtů
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +667,Supplier Invoice No exists in Purchase Invoice {0},Dodavatelské faktury No existuje ve faktuře {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673,Supplier Invoice No exists in Purchase Invoice {0},Dodavatelské faktury No existuje ve faktuře {0}
 apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Správa obchodník strom.
 DocType: Job Applicant,Cover Letter,Průvodní dopis
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Vynikající Šeky a vklady s jasnými
@@ -462,7 +462,8 @@
 apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Nastavení Daně
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Náklady prodaných aktiv
 DocType: Volunteer,Morning,Ráno
-apps/erpnext/erpnext/accounts/utils.py +347,Payment Entry has been modified after you pulled it. Please pull it again.,"Vstup Platba byla změněna poté, co ji vytáhl. Prosím, vytáhněte ji znovu."
+apps/erpnext/erpnext/accounts/utils.py +350,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 +464,{0} entered twice in Item Tax,{0} vloženo dvakrát v Daňové Položce
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Shrnutí pro tento týden a probíhajícím činnostem
 DocType: Student Applicant,Admitted,"připustil,"
@@ -483,13 +484,13 @@
 apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Označení zaměstnanců (např CEO, ředitel atd.)."
 DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je měna zákazníka převedena na základní měnu zákazníka"
 DocType: Course Scheduling Tool,Course Scheduling Tool,Samozřejmě Plánování Tool
-apps/erpnext/erpnext/controllers/accounts_controller.py +602,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Řádek # {0}: faktury nelze provést vůči stávajícímu aktivu {1}
+apps/erpnext/erpnext/controllers/accounts_controller.py +613,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Řádek # {0}: faktury nelze provést vůči stávajícímu aktivu {1}
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Urgentní] Chyba při vytváření opakujících se %s pro %s
 DocType: Land Unit,LInked Analysis,Llnked Analysis
 DocType: Item Tax,Tax Rate,Tax Rate
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} již přidělené pro zaměstnance {1} na dobu {2} až {3}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +915,Select Item,Select Položka
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +140,Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +919,Select Item,Select Položka
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141,Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},"Row # {0}: Batch No musí být stejné, jako {1} {2}"
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Převést na non-Group
 DocType: C-Form Invoice Detail,Invoice Date,Datum Fakturace
@@ -543,7 +544,7 @@
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Důvod ztráty
 apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Aktualizovat číslo účtu
 apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Olovo Majitel nemůže být stejný jako olovo
-apps/erpnext/erpnext/accounts/utils.py +353,Allocated amount can not greater than unadjusted amount,Přidělená částka nemůže větší než množství neupravené
+apps/erpnext/erpnext/accounts/utils.py +356,Allocated amount can not greater than unadjusted amount,Přidělená částka nemůže větší než množství neupravené
 DocType: Announcement,Receiver,Přijímač
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation je uzavřena v následujících dnech podle Prázdninový Seznam: {0}
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Příležitosti
@@ -551,7 +552,7 @@
 DocType: Salary Slip,Total Loan Repayment,Celková splátky
 DocType: Account,Cost of Goods Sold,Náklady na prodej zboží
 DocType: Subscription,Yearly,Ročně
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +228,Please enter Cost Center,"Prosím, zadejte nákladové středisko"
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,Please enter Cost Center,"Prosím, zadejte nákladové středisko"
 DocType: Drug Prescription,Dosage,Dávkování
 DocType: Journal Entry Account,Sales Order,Prodejní objednávky
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Selling Rate,Avg. Prodej Rate
@@ -606,7 +607,6 @@
 DocType: Item Attribute,To Range,K Rozsah
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Cenné papíry a vklady
 apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Metoda oceňování nelze změnit, neboť existují transakce proti některým položkám, které nemají vlastní metodu oceňování"
-apps/erpnext/erpnext/config/healthcare.py +133,Test Sample Master.,Testovací vzorek Master.
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Celkem listy přidělené je povinné
 DocType: Patient,AB Positive,AB pozitivní
 DocType: Job Opening,Description of a Job Opening,Popis jednoho volných pozic
@@ -627,7 +627,6 @@
 DocType: Training Event,Workshop,Dílna
 DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Upozornění na nákupní objednávky
 apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Seznam několik svých zákazníků. Ty by mohly být organizace nebo jednotlivci.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Dodavatel&gt; Typ dodavatele
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +21,Enough Parts to Build,Dost Části vybudovat
 DocType: POS Profile User,POS Profile User,Uživatel profilu POS
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Přímý příjmů
@@ -674,7 +673,7 @@
 DocType: Physician,OP Consulting Charge,Konzultační poplatek OP
 apps/erpnext/erpnext/utilities/user_progress.py +25,Setup your ,Nastavte si
 DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou je ceníková měna převedena na základní měnu společnosti"
-apps/erpnext/erpnext/setup/doctype/company/company.py +62,Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1}
+apps/erpnext/erpnext/setup/doctype/company/company.py +69,Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1}
 apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Zkratka již byla použita pro jinou společnost
 DocType: Selling Settings,Default Customer Group,Výchozí Customer Group
 DocType: Asset Repair,ARLOG-,ARLOG-
@@ -701,7 +700,7 @@
 apps/erpnext/erpnext/accounts/party.py +384,{0} {1} is not active,{0} {1} není aktivní
 apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Zkontrolujte nastavení rozměry pro tisk
 DocType: Salary Slip,Salary Slip Timesheet,Plat Slip časový rozvrh
-apps/erpnext/erpnext/controllers/buying_controller.py +157,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení
+apps/erpnext/erpnext/controllers/buying_controller.py +160,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení
 DocType: Pricing Rule,Valid From,Platnost od
 DocType: Sales Invoice,Total Commission,Celkem Komise
 DocType: Pricing Rule,Sales Partner,Sales Partner
@@ -714,7 +713,7 @@
 apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Finanční / Účetní rok.
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Neuhrazená Hodnoty
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit"
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +68,Territory is Required in POS Profile,Území je vyžadováno v POS profilu
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Území je vyžadováno v POS profilu
 DocType: Supplier,Prevent RFQs,Zabraňte RFQ
 apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Ujistěte se prodejní objednávky
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Zápis o platu odeslán na období od {0} do {1}
@@ -749,7 +748,7 @@
 DocType: Lead,Middle Income,Středními příjmy
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +225,Opening (Cr),Otvor (Cr)
 apps/erpnext/erpnext/stock/doctype/item/item.py +835,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Výchozí měrná jednotka bodu {0} nemůže být změněna přímo, protože jste už nějaké transakce (y) s jiným nerozpuštěných. Budete muset vytvořit novou položku použít jiný výchozí UOM."
-apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not be negative,Přidělená částka nemůže být záporná
+apps/erpnext/erpnext/accounts/utils.py +354,Allocated amount can not be negative,Přidělená částka nemůže být záporná
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Nastavte společnost
 DocType: Purchase Order Item,Billed Amt,Účtovaného Amt
 DocType: Training Result Employee,Training Result Employee,Vzdělávací Výsledek
@@ -761,7 +760,6 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0}
 DocType: Payroll Entry,Select Payment Account to make Bank Entry,"Vybrat Platební účet, aby Bank Entry"
 apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Vytvořit Zaměstnanecké záznamy pro správu listy, prohlášení o výdajích a mezd"
-apps/erpnext/erpnext/config/healthcare.py +118,Prescription Period,Předepsaná doba
 DocType: Restaurant Reservation,Restaurant Reservation,Rezervace restaurace
 DocType: Land Unit,Land Unit Name,Název půdní jednotky
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Návrh Psaní
@@ -771,7 +769,7 @@
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Další prodeje osoba {0} existuje se stejným id zaměstnance
 DocType: Employee Advance,Claimed Amount,Požadovaná částka
 DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Je-li zaškrtnuto, suroviny pro položky, které jsou subdodavatelsky budou zahrnuty v materiálu Žádosti"
-apps/erpnext/erpnext/config/healthcare.py +61,Masters,Masters
+apps/erpnext/erpnext/config/healthcare.py +62,Masters,Masters
 DocType: Assessment Plan,Maximum Assessment Score,Maximální skóre Assessment
 apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Transakční Data aktualizace Bank
 apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Time Tracking
@@ -783,7 +781,7 @@
 DocType: Timesheet,Billed,Fakturováno
 DocType: Batch,Batch Description,Popis Šarže
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Vytváření studentských skupin
-apps/erpnext/erpnext/accounts/utils.py +724,"Payment Gateway Account not created, please create one manually.","Platební brána účet nevytvořili, prosím, vytvořte ručně."
+apps/erpnext/erpnext/accounts/utils.py +727,"Payment Gateway Account not created, please create one manually.","Platební brána účet nevytvořili, prosím, vytvořte ručně."
 DocType: Supplier Scorecard,Per Year,Za rok
 apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Není způsobilý pro přijetí do tohoto programu podle DOB
 DocType: Sales Invoice,Sales Taxes and Charges,Prodej Daně a poplatky
@@ -812,6 +810,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Manažer
 DocType: Payment Entry,Payment From / To,Platba z / do
 apps/erpnext/erpnext/selling/doctype/customer/customer.py +155,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nový úvěrový limit je nižší než aktuální dlužné částky za zákazníka. Úvěrový limit musí být aspoň {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428,Please set account in Warehouse {0},Nastavte prosím účet ve skladu {0}
 apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""Založeno na"" a ""Seskupeno podle"", nemůže být stejné"
 DocType: Sales Person,Sales Person Targets,Obchodník cíle
 DocType: Installation Note,IN-,V-
@@ -856,10 +855,10 @@
 DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Přistál nákladů daně a poplatky
 DocType: Production Order Operation,Actual Start Time,Skutečný čas začátku
 DocType: BOM Operation,Operation Time,Čas operace
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +315,Finish,Dokončit
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +316,Finish,Dokončit
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Báze
 DocType: Timesheet,Total Billed Hours,Celkem Předepsané Hodiny
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1438,Write Off Amount,Odepsat Částka
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1446,Write Off Amount,Odepsat Částka
 DocType: Leave Block List Allow,Allow User,Umožňuje uživateli
 DocType: Journal Entry,Bill No,Bill No
 DocType: Company,Gain/Loss Account on Asset Disposal,Zisk / ztráty na majetku likvidaci
@@ -873,10 +872,11 @@
 DocType: Student Attendance,Student Attendance,Student Účast
 DocType: Sales Invoice Timesheet,Time Sheet,Rozvrh hodin
 DocType: Manufacturing Settings,Backflush Raw Materials Based On,Se zpětným suroviny na základě
+DocType: Purchase Order Item Supplied,Reserve Warehouse,Rezervní sklad
 DocType: Lead,Lead is an Organization,Vedoucí je organizace
 DocType: Guardian Interest,Interest,Zajímat
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Předprodej
-DocType: Purchase Receipt,Other Details,Další podrobnosti
+DocType: Instructor Log,Other Details,Další podrobnosti
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
 DocType: Lab Test,Test Template,Testovací šablona
 DocType: Restaurant Order Entry Item,Served,Podával
@@ -888,11 +888,11 @@
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,Vstup Platba je již vytvořili
 DocType: Request for Quotation,Get Suppliers,Získejte dodavatele
 DocType: Purchase Receipt Item Supplied,Current Stock,Current skladem
-apps/erpnext/erpnext/controllers/accounts_controller.py +589,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 +600,Row #{0}: Asset {1} does not linked to Item {2},Řádek # {0}: Asset {1} není spojena s item {2}
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Preview výplatní pásce
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Účet {0} byl zadán vícekrát
 DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
-apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +23,You can only renew if your membership expires within 30 days,"Můžete obnovit pouze tehdy, pokud vaše členství vyprší během 30 dnů"
+apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,"Můžete obnovit pouze tehdy, pokud vaše členství vyprší během 30 dnů"
 DocType: Land Unit,Longitude,Zeměpisná délka
 ,Absent Student Report,Absent Student Report
 DocType: Crop,Crop Spacing UOM,Rozdělení výsevních ploch UOM
@@ -904,7 +904,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Položka {0} nebyl nalezen
 DocType: Bin,Stock Value,Reklamní Value
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,V pozadí budou vytvořeny záznamy o poplatcích. V případě jakékoliv chyby bude chybová zpráva aktualizována v rozvrhu.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +241,Company {0} does not exist,Společnost {0} neexistuje
+apps/erpnext/erpnext/accounts/doctype/account/account.py +239,Company {0} does not exist,Společnost {0} neexistuje
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} má platnost až do {1}
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Tree Type
 DocType: BOM Explosion Item,Qty Consumed Per Unit,Množství spotřebované na jednotku
@@ -919,7 +919,6 @@
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Aerospace
 DocType: Journal Entry,Credit Card Entry,Vstup Kreditní karta
 apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Společnost a účty
-apps/erpnext/erpnext/config/healthcare.py +108,Appointment Type Master,Typ schůzky Master
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,v Hodnota
 DocType: Lead,Campaign Name,Název kampaně
 DocType: Selling Settings,Close Opportunity After Days,V blízkosti Příležitost po několika dnech
@@ -927,7 +926,7 @@
 DocType: Driver,License Details,Podrobnosti licence
 DocType: Purchase Order,Supply Raw Materials,Dodávek surovin
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Oběžná aktiva
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,{0} is not a stock Item,{0} není skladová položka
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +104,{0} is not a stock Item,{0} není skladová položka
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Podělte se o své připomínky k tréninku kliknutím na &quot;Tréninkové připomínky&quot; a poté na &quot;Nové&quot;
 DocType: Mode of Payment Account,Default Account,Výchozí účet
 apps/erpnext/erpnext/stock/doctype/item/item.py +262,Please select Sample Retention Warehouse in Stock Settings first,Zvolte prosím nejprve Sample Retention Warehouse in Stock Stock
@@ -937,7 +936,7 @@
 DocType: Patient,O Negative,O Negativní
 DocType: Production Order Operation,Planned End Time,Plánované End Time
 ,Sales Person Target Variance Item Group-Wise,Prodej Osoba Cílová Odchylka Item Group-Wise
-apps/erpnext/erpnext/accounts/doctype/account/account.py +95,Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu
+apps/erpnext/erpnext/accounts/doctype/account/account.py +93,Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu
 apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Podrobnosti o typu člena
 DocType: Delivery Note,Customer's Purchase Order No,Zákazníka Objednávka No
 DocType: Budget,Budget Against,rozpočet Proti
@@ -956,17 +955,17 @@
 DocType: BOM,Website Specifications,Webových stránek Specifikace
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} je neplatná e-mailová adresa v adresáři &quot;Příjemci&quot;
 DocType: Special Test Items,Particulars,Podrobnosti
-apps/erpnext/erpnext/config/healthcare.py +143,Antibiotic.,Antibiotikum.
+apps/erpnext/erpnext/config/healthcare.py +144,Antibiotic.,Antibiotikum.
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Od {0} typu {1}
 DocType: Warranty Claim,CI-,Ci
-apps/erpnext/erpnext/controllers/buying_controller.py +292,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
+apps/erpnext/erpnext/controllers/buying_controller.py +310,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
 DocType: Student,A+,A+
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +326,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Více Cena pravidla existuje u stejných kritérií, prosím vyřešit konflikt tím, že přiřadí prioritu. Cena Pravidla: {0}"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +504,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nelze deaktivovat nebo zrušit BOM, jak to souvisí s ostatními kusovníky"
 DocType: Asset,Maintenance,Údržba
 DocType: Item Attribute Value,Item Attribute Value,Položka Hodnota atributu
 DocType: Item,Maximum sample quantity that can be retained,"Maximální množství vzorku, které lze zadržet"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +393,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Řádek {0} # Položka {1} nelze převést více než {2} na objednávku {3}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +398,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Řádek {0} # Položka {1} nelze převést více než {2} na objednávku {3}
 apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Prodej kampaně.
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,Udělat TimeSheet
 DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
@@ -1029,8 +1028,8 @@
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +234,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionována Částka nemůže být větší než reklamace Částka v řádku {0}.
 DocType: Salary Detail,Do not include in total,Nezahrnujte celkem
 DocType: Company,Default Cost of Goods Sold Account,Výchozí Náklady na prodané zboží účtu
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +964,Sample quantity {0} cannot be more than received quantity {1},Množství vzorku {0} nemůže být větší než přijaté množství {1}
-apps/erpnext/erpnext/stock/get_item_details.py +362,Price List not selected,Ceník není zvolen
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +997,Sample quantity {0} cannot be more than received quantity {1},Množství vzorku {0} nemůže být větší než přijaté množství {1}
+apps/erpnext/erpnext/stock/get_item_details.py +367,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 +218,Warning: Invalid Attachment {0},Varování: Neplatná Příloha {0}
@@ -1046,7 +1045,7 @@
 DocType: Item,Items with higher weightage will be shown higher,Položky s vyšším weightage budou zobrazeny vyšší
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Laboratorní testy a vitální znaky
 DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Odsouhlasení Detail
-apps/erpnext/erpnext/controllers/accounts_controller.py +593,Row #{0}: Asset {1} must be submitted,Řádek # {0}: {1} Asset musí být předloženy
+apps/erpnext/erpnext/controllers/accounts_controller.py +604,Row #{0}: Asset {1} must be submitted,Řádek # {0}: {1} Asset musí být předloženy
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Žádný zaměstnanec nalezeno
 DocType: Subscription,Stopped,Zastaveno
 DocType: Item,If subcontracted to a vendor,Pokud se subdodávky na dodavatele
@@ -1076,7 +1075,8 @@
 apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Podpora dotazy ze strany zákazníků.
 DocType: Setup Progress Action,Action Doctype,Akce Doctype
 ,Production Order Stock Report,Zakázková výroba Reklamní Zpráva
-apps/erpnext/erpnext/config/healthcare.py +148,Sensitivity Naming.,Citlivost Pojmenování.
+apps/erpnext/erpnext/config/healthcare.py +149,Sensitivity Naming.,Citlivost Pojmenování.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Dodavatel&gt; Typ dodavatele
 DocType: HR Settings,Retirement Age,Duchodovy vek
 DocType: Bin,Moving Average Rate,Klouzavý průměr
 DocType: Production Planning Tool,Select Items,Vyberte položky
@@ -1090,7 +1090,6 @@
 DocType: Crop,Target Warehouse,Target Warehouse
 DocType: Payroll Employee Detail,Payroll Employee Detail,Zaměstnanecký detail zaměstnanců
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,Vyberte prosím sklad
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Prosím, nastavte číselnou sérii pro Účast přes Nastavení&gt; Číslovací série"
 DocType: Cheque Print Template,Starting location from left edge,Počínaje umístění od levého okraje
 DocType: Item,Allow over delivery or receipt upto this percent,Nechte přes dodávku nebo příjem aľ tohoto procenta
 DocType: Stock Entry,STE-,STE-
@@ -1098,7 +1097,6 @@
 apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Všechny skupiny položek
 apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Čistý zisk / ztráta
 apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Automaticky napsat vzkaz na předkládání transakcí.
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte prosím jmenovací řadu pro {0} přes Nastavení&gt; Nastavení&gt; Pojmenování
 DocType: Production Order,Item To Manufacture,Položka k výrobě
 apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} je stav {2}
 DocType: Water Analysis,Collection Temperature ,Teplota sběru
@@ -1138,13 +1136,13 @@
 DocType: Customer,Bypass credit limit check at Sales Order,Zablokujte kontrolu úvěrového limitu na objednávce
 apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Hodnocení výkonu.
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Povolení &quot;použití pro nákupního košíku&quot;, jak je povoleno Nákupní košík a tam by měla být alespoň jedna daňová pravidla pro Košík"
-apps/erpnext/erpnext/controllers/accounts_controller.py +391,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Platba Vstup {0} je propojen na objednávku {1}, zkontrolujte, zda by měl být tažen za pokrok v této faktuře."
+apps/erpnext/erpnext/controllers/accounts_controller.py +402,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Platba Vstup {0} je propojen na objednávku {1}, zkontrolujte, zda by měl být tažen za pokrok v této faktuře."
 DocType: Sales Invoice Item,Stock Details,Sklad Podrobnosti
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Hodnota projektu
 apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Místě prodeje
 DocType: Fee Schedule,Fee Creation Status,Stav tvorby poplatků
 DocType: Vehicle Log,Odometer Reading,stav tachometru
-apps/erpnext/erpnext/accounts/doctype/account/account.py +118,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zůstatek na účtu již v Credit, není dovoleno stanovit ""Balance musí být"" jako ""debet"""
+apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zůstatek na účtu již v Credit, není dovoleno stanovit ""Balance musí být"" jako ""debet"""
 DocType: Account,Balance must be,Zůstatek musí být
 DocType: Hub Settings,Publish Pricing,Publikovat Ceník
 DocType: Notification Control,Expense Claim Rejected Message,Zpráva o zamítnutí úhrady výdajů
@@ -1177,7 +1175,7 @@
 DocType: Production Order,Plan material for sub-assemblies,Plán materiál pro podsestavy
 apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Obchodní partneři a teritoria
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +585,BOM {0} must be active,BOM {0} musí být aktivní
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +221,Closing (Opening + Total),Uzavření (otevření + celkem)
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +228,Closing (Opening + Total),Uzavření (otevření + celkem)
 DocType: Journal Entry,Depreciation Entry,odpisy Entry
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Vyberte první typ dokumentu
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušit Materiál Návštěvy {0} před zrušením tohoto návštěv údržby
@@ -1214,6 +1212,7 @@
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Záloha přijaté faktury
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +197,Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
 apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Definovat rozpočet pro finanční rok.
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte prosím jmenovací řadu pro {0} přes Nastavení&gt; Nastavení&gt; Pojmenování
 DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Výchozí účet Bank / Cash budou automaticky aktualizovány v POS faktury, pokud je zvolen tento režim."
 DocType: Lead,LEAD-,VÉST-
 DocType: Employee,Permanent Address Is,Trvalé bydliště je
@@ -1242,11 +1241,11 @@
 DocType: Cheque Print Template,Has Print Format,Má formát tisku
 DocType: Employee Loan,Sanctioned,schválený
 apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,je povinné. Možná chybí záznam směnného kurzu pro
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +117,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +122,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
 DocType: Crop Cycle,Crop Cycle,Crop Cycle
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +632,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pro &quot;produktem Bundle předměty, sklad, sériové číslo a dávkové No bude považována ze&quot; Balení seznam &#39;tabulky. Pokud Warehouse a Batch No jsou stejné pro všechny balení položky pro jakoukoli &quot;Výrobek balík&quot; položky, tyto hodnoty mohou být zapsány do hlavní tabulky položky, budou hodnoty zkopírovány do &quot;Balení seznam&quot; tabulku."
 DocType: Student Admission,Publish on website,Publikovat na webových stránkách
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +645,Supplier Invoice Date cannot be greater than Posting Date,Dodavatel Datum faktury nemůže být větší než Datum zveřejnění
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,Supplier Invoice Date cannot be greater than Posting Date,Dodavatel Datum faktury nemůže být větší než Datum zveřejnění
 DocType: Purchase Invoice Item,Purchase Order Item,Položka vydané objednávky
 DocType: Agriculture Task,Agriculture Task,Zemědělské úkoly
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Nepřímé příjmy
@@ -1256,7 +1255,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Odchylka
 ,Company Name,Název společnosti
 DocType: SMS Center,Total Message(s),Celkem zpráv (y)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +913,Select Item for Transfer,Vybrat položku pro převod
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +917,Select Item for Transfer,Vybrat položku pro převod
 DocType: Purchase Invoice,Additional Discount Percentage,Další slevy Procento
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Zobrazit seznam všech nápovědy videí
 DocType: Agriculture Analysis Criteria,Soil Texture,Půdní textury
@@ -1269,7 +1268,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Chemický
 DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Výchozí banka / Peněžní účet budou automaticky aktualizovány v plat položka deníku je-li zvolen tento režim.
 DocType: BOM,Raw Material Cost(Company Currency),Raw Material Cost (Company měna)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +758,All items have already been transferred for this Production Order.,Všechny položky již byly převedeny na výrobu tohoto řádu.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +775,All items have already been transferred for this Production Order.,Všechny položky již byly převedeny na výrobu tohoto řádu.
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Řádek # {0}: Míra nemůže být větší než rychlost použitá v {1} {2}
 apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,Metr
 DocType: Workstation,Electricity Cost,Cena elektřiny
@@ -1287,7 +1286,7 @@
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Vedle Odpisy Datum se zadává jako uplynulém dni
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Bílá
 DocType: SMS Center,All Lead (Open),Všechny Lead (Otevřeny)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +248,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Řádek {0}: Množství není k dispozici pro {4} ve skladu {1} při účtování čas vložení údajů ({2} {3})
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Řádek {0}: Množství není k dispozici pro {4} ve skladu {1} při účtování čas vložení údajů ({2} {3})
 DocType: Purchase Invoice,Get Advances Paid,Získejte zaplacené zálohy
 DocType: Item,Automatically Create New Batch,Automaticky vytvořit novou dávku
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Make ,Dělat
@@ -1296,20 +1295,21 @@
 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 +126,Order Type must be one of {0},Typ objednávky musí být jedním z {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +129,Order Type must be one of {0},Typ objednávky musí být jedním z {0}
 DocType: Lead,Next Contact Date,Další Kontakt Datum
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Otevření POČET
 DocType: Healthcare Settings,Appointment Reminder,Připomenutí pro jmenování
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +472,Please enter Account for Change Amount,"Prosím, zadejte účet pro změnu Částka"
-DocType: Student Batch Name,Student Batch Name,Student Batch Name
+DocType: Program Enrollment Tool Student,Student Batch Name,Student Batch Name
 DocType: Consultation,Doctor,Doktor
 DocType: Holiday List,Holiday List Name,Název seznamu dovolené
 DocType: Repayment Schedule,Balance Loan Amount,Balance Výše úvěru
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,rozvrh
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Stock Options,Akciové opce
+DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Zakázat načíst poslední nákupní údaje v objednávce
 DocType: Journal Entry Account,Expense Claim,Hrazení nákladů
 apps/erpnext/erpnext/assets/doctype/asset/asset.js +254,Do you really want to restore this scrapped asset?,Opravdu chcete obnovit tento vyřazen aktivum?
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +380,Qty for {0},Množství pro {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Qty for {0},Množství pro {0}
 DocType: Leave Application,Leave Application,Požadavek na absenci
 DocType: Patient,Patient Relation,Vztah pacienta
 apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Nástroj pro přidělování dovolených
@@ -1323,14 +1323,14 @@
 DocType: Packing Slip Item,Packing Slip Item,Položka balícího listu
 DocType: Purchase Invoice,Cash/Bank Account,Hotovostní / Bankovní účet
 apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Zadejte {0}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Removed items with no change in quantity or value.,Odstraněné položky bez změny množství nebo hodnoty.
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73,Removed items with no change in quantity or value.,Odstraněné položky bez změny množství nebo hodnoty.
 DocType: Delivery Note,Delivery To,Doručení do
 apps/erpnext/erpnext/stock/doctype/item/item.js +384,Variant creation has been queued.,Tvorba variantu byla zařazena do fronty.
 apps/erpnext/erpnext/stock/doctype/item/item.py +668,Attribute table is mandatory,Atribut tabulka je povinné
 DocType: Production Planning Tool,Get Sales Orders,Získat Prodejní objednávky
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} nemůže být negativní
 DocType: Training Event,Self-Study,Samostudium
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +537,Discount,Sleva
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +544,Discount,Sleva
 DocType: Membership,Membership,Členství
 DocType: Asset,Total Number of Depreciations,Celkový počet Odpisy
 DocType: Sales Invoice Item,Rate With Margin,Míra s marží
@@ -1339,7 +1339,7 @@
 DocType: Agriculture Task,Urgent,Naléhavý
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Zadejte prosím platný řádek ID řádku tabulky {0} {1}
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Nelze najít proměnnou:
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +723,Please select a field to edit from numpad,"Vyberte pole, které chcete upravit z čísla"
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +730,Please select a field to edit from numpad,"Vyberte pole, které chcete upravit z čísla"
 apps/erpnext/erpnext/stock/doctype/item/item.py +253,Cannot be a fixed asset item as Stock Ledger is created.,"Nemůže být položka fixního aktiva, protože je vytvořena účetní kniha akcií."
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Přejděte na plochu a začít používat ERPNext
 DocType: Item,Manufacturer,Výrobce
@@ -1372,7 +1372,7 @@
 DocType: Item,Default Selling Cost Center,Výchozí Center Prodejní cena
 DocType: Sales Partner,Implementation Partner,Implementačního partnera
 apps/erpnext/erpnext/accounts/page/pos/pos.js +1613,ZIP Code,PSČ
-apps/erpnext/erpnext/controllers/selling_controller.py +245,Sales Order {0} is {1},Prodejní objednávky {0} {1}
+apps/erpnext/erpnext/controllers/selling_controller.py +248,Sales Order {0} is {1},Prodejní objednávky {0} {1}
 DocType: Opportunity,Contact Info,Kontaktní informace
 apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Tvorba přírůstků zásob
 DocType: Packing Slip,Net Weight UOM,Hmotnost UOM
@@ -1387,7 +1387,7 @@
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +202,Email sent to {0},Email odeslán (komu) {0}
 apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Nabídka obdržená od Dodavatelů.
 apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Nahraďte kusovníku a aktualizujte nejnovější cenu ve všech kusovnících
-apps/erpnext/erpnext/controllers/selling_controller.py +24,To {0} | {1} {2},Chcete-li {0} | {1} {2}
+apps/erpnext/erpnext/controllers/selling_controller.py +27,To {0} | {1} {2},Chcete-li {0} | {1} {2}
 DocType: Delivery Trip,Driver Name,Jméno řidiče
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Průměrný věk
 DocType: Education Settings,Attendance Freeze Date,Datum ukončení účasti
@@ -1398,7 +1398,7 @@
 DocType: Patient,Default Currency,Výchozí měna
 DocType: Expense Claim,From Employee,Od Zaměstnance
 DocType: Driver,Cellphone Number,Mobilní číslo
-apps/erpnext/erpnext/controllers/accounts_controller.py +451,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornění: Systém nebude kontrolovat nadfakturace, protože částka za položku na {1} je nula {0}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +462,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornění: Systém nebude kontrolovat nadfakturace, protože částka za položku na {1} je nula {0}"
 DocType: Journal Entry,Make Difference Entry,Učinit vstup Rozdíl
 DocType: Upload Attendance,Attendance From Date,Účast Datum od
 DocType: Appraisal Template Goal,Key Performance Area,Key Performance Area
@@ -1409,7 +1409,7 @@
 DocType: SMS Center,Total Characters,Celkový počet znaků
 DocType: Employee Advance,Claimed,Reklamace
 DocType: Crop,Row Spacing,Rozteč řádků
-apps/erpnext/erpnext/controllers/buying_controller.py +161,Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
+apps/erpnext/erpnext/controllers/buying_controller.py +164,Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
 DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detail
 DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Platba Odsouhlasení faktury
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Příspěvek%
@@ -1434,7 +1434,7 @@
 ,Trial Balance for Party,Trial váhy pro stranu
 DocType: Lead,Consultant,Konzultant
 DocType: Salary Slip,Earnings,Výdělek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +416,Finished Item {0} must be entered for Manufacture type entry,Dokončeno Položka {0} musí být zadán pro vstup typu Výroba
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +421,Finished Item {0} must be entered for Manufacture type entry,Dokončeno Položka {0} musí být zadán pro vstup typu Výroba
 apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Otevření účetnictví Balance
 ,GST Sales Register,Obchodní registr GST
 DocType: Sales Invoice Advance,Sales Invoice Advance,Prodejní faktury Advance
@@ -1448,7 +1448,7 @@
 DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To bude připojen na položku zákoníku varianty. Například, pokud vaše zkratka je ""SM"", a položka je kód ""T-SHIRT"", položka kód varianty bude ""T-SHIRT-SM"""
 DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Čistá Pay (slovy) budou viditelné, jakmile uložíte výplatní pásce."
 DocType: Purchase Invoice,Is Return,Je Return
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,Caution,Pozor
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +82,Caution,Pozor
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,Return / Debit Note,Return / vrubopis
 DocType: Price List Country,Price List Country,Ceník Země
 DocType: Item,UOMs,UOMs
@@ -1470,9 +1470,10 @@
 DocType: Email Digest,Payables,Závazky
 DocType: Course,Course Intro,Samozřejmě Intro
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +97,Stock Entry {0} created,Skladovou pohyb {0} vytvořil
-apps/erpnext/erpnext/controllers/buying_controller.py +298,Row #{0}: Rejected Qty can not be entered in Purchase Return,Řádek # {0}: Zamítnutí Množství nemůže být zapsán do kupní Návrat
+apps/erpnext/erpnext/controllers/buying_controller.py +316,Row #{0}: Rejected Qty can not be entered in Purchase Return,Řádek # {0}: Zamítnutí Množství nemůže být zapsán do kupní Návrat
 ,Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Updating estimated arrival times.,Aktualizace odhadovaných časů příjezdu.
+DocType: Program Enrollment Tool,Enrollment Details,Podrobnosti o zápisu
 DocType: Purchase Invoice Item,Net Rate,Čistá míra
 apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +147,Please select a customer,Vyberte zákazníka
 DocType: Purchase Invoice Item,Purchase Invoice Item,Položka přijaté faktury
@@ -1539,7 +1540,7 @@
 ,Employee Leave Balance,Zaměstnanec Leave Balance
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Zůstatek na účtě {0} musí být vždy {1}
 DocType: Patient Appointment,More Info,Více informací
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +178,Valuation Rate required for Item in row {0},Ocenění Míra potřebná pro položku v řádku {0}
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},Ocenění Míra potřebná pro položku v řádku {0}
 DocType: Supplier Scorecard,Scorecard Actions,Akční body Scorecard
 apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Příklad: Masters v informatice
 DocType: Purchase Invoice,Rejected Warehouse,Zamítnuto Warehouse
@@ -1555,7 +1556,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Prodejní objednávky {0} není platný
 DocType: Supplier Scorecard,Warn for new Request for Quotations,Upozornit na novou žádost o nabídky
 apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Objednávky pomohou při plánování a navázat na vašich nákupech
-apps/erpnext/erpnext/setup/doctype/company/company.py +215,"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
+apps/erpnext/erpnext/setup/doctype/company/company.py +222,"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Předpisy pro laboratorní testy
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +162,"The total Issue / Transfer quantity {0} in Material Request {1}  \
 							cannot be greater than requested quantity {2} for Item {3}",Celkové emise / přenosu množství {0} v hmotné Request {1} \ nemůže být vyšší než požadované množství {2} pro položku {3}
@@ -1574,9 +1575,9 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Smlouva
 DocType: Plant Analysis,Laboratory Testing Datetime,Laboratorní testování Datetime
 DocType: Email Digest,Add Quote,Přidat nabídku
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +932,UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktor potřebný k nerozpuštěných: {0} v bodě: {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +965,UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion faktor potřebný k nerozpuštěných: {0} v bodě: {1}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Nepřímé náklady
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
 DocType: Agriculture Analysis Criteria,Agriculture,Zemědělství
 apps/erpnext/erpnext/accounts/page/pos/pos.js +785,Sync Master Data,Sync Master Data
 DocType: Asset Repair,Repair Cost,náklady na opravu
@@ -1608,9 +1609,9 @@
 apps/erpnext/erpnext/stock/get_item_details.py +146,Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Kapitálové Vybavení
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Ceny Pravidlo je nejprve vybrána na základě ""Použít na"" oblasti, které mohou být položky, položky skupiny nebo značky."
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +245,Please set the Item Code first,Nejprve nastavte kód položky
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +246,Please set the Item Code first,Nejprve nastavte kód položky
 DocType: Item,ITEM-,POLOŽKA-
-apps/erpnext/erpnext/controllers/selling_controller.py +119,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
+apps/erpnext/erpnext/controllers/selling_controller.py +122,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
 DocType: Sales Invoice Item,Edit Description,Upravit popis
 DocType: Antibiotic,Antibiotic,Antibiotikum
 ,Team Updates,tým Aktualizace
@@ -1693,7 +1694,7 @@
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Období pro podávání žádostí nemůže být alokační období venku volno
 DocType: Activity Cost,Projects,Projekty
 DocType: Payment Request,Transaction Currency,Transakční měna
-apps/erpnext/erpnext/controllers/buying_controller.py +27,From {0} | {1} {2},Od {0} | {1} {2}
+apps/erpnext/erpnext/controllers/buying_controller.py +30,From {0} | {1} {2},Od {0} | {1} {2}
 DocType: Production Order Operation,Operation Description,Operace Popis
 DocType: Item,Will also apply to variants,Bude se vztahovat i na varianty
 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ží."
@@ -1711,13 +1712,13 @@
 DocType: Purchase Invoice Item,Item Tax Amount,Částka Daně Položky
 DocType: Water Analysis,Water Analysis Criteria,Kritéria analýzy vody
 DocType: Item,Maintain Stock,Udržovat stav zásob
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217,Stock Entries already created for Production Order ,Fotky Položky již vytvořené pro výrobní zakázku
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +222,Stock Entries already created for Production Order ,Fotky Položky již vytvořené pro výrobní zakázku
 DocType: Employee,Prefered Email,preferovaný Email
 DocType: Student Admission,Eligibility and Details,Způsobilost a podrobnosti
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Čistá změna ve stálých aktiv
 DocType: Leave Control Panel,Leave blank if considered for all designations,"Ponechte prázdné, pokud se to považuje za všechny označení"
-apps/erpnext/erpnext/controllers/accounts_controller.py +775,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Obvinění z typu ""Aktuální"" v řádku {0} nemůže být zařazena do položky Rate"
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Max: {0},Max: {0}
+apps/erpnext/erpnext/controllers/accounts_controller.py +786,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Obvinění z typu ""Aktuální"" v řádku {0} nemůže být zařazena do položky Rate"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +382,Max: {0},Max: {0}
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Od datetime
 DocType: Email Digest,For Company,Pro Společnost
 apps/erpnext/erpnext/config/support.py +17,Communication log.,Komunikační protokol.
@@ -1749,7 +1750,7 @@
 DocType: Package Code,Package Code,Code Package
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,Učeň
 DocType: Purchase Invoice,Company GSTIN,Společnost GSTIN
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Negativní množství není dovoleno
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,Negative Quantity is not allowed,Negativní množství není dovoleno
 DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
 Used for Taxes and Charges","Tax detail tabulka staženy z položky pána jako řetězec a uložené v této oblasti.
  Používá se daní a poplatků"
@@ -1764,6 +1765,7 @@
 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é)
+apps/erpnext/erpnext/config/healthcare.py +154,Lab Test Template.,Šablona zkušebního laboratoře.
 DocType: Weather,Weather Parameter,Parametr počasí
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Ukázat P &amp; L zůstatky neuzavřený fiskální rok je
 DocType: Lab Test Template,Collection Details,Podrobnosti o kolekci
@@ -1781,7 +1783,7 @@
 DocType: Project,Task Weight,úkol Hmotnost
 DocType: Shipping Rule Condition,To Value,Chcete-li hodnota
 DocType: Asset Movement,Stock Manager,Reklamní manažer
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +149,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +154,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
 apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Platba v řádku {0} je možná duplikát.
 apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Zemědělství (beta)
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +856,Packing Slip,Balící list
@@ -1836,7 +1838,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Nastavení výchozích hodnot
 apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,vytvoření vede
 DocType: Maintenance Schedule,Schedules,Plány
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +451,POS Profile is required to use Point-of-Sale,Profil POS je vyžadován pro použití prodejního místa
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +458,POS Profile is required to use Point-of-Sale,Profil POS je vyžadován pro použití prodejního místa
 DocType: Purchase Invoice Item,Net Amount,Čistá částka
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +138,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nebyla odeslána, takže akce nemůže být dokončena"
 DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail No
@@ -1869,7 +1871,6 @@
 DocType: Water Analysis,Container,Kontejner
 apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} objeví vícekrát za sebou {2} {3}
 DocType: Healthcare Settings,Manage Sample Collection,Správa kolekce vzorků
-DocType: Program Enrollment Tool,Program Enrollments,Program Přihlášky
 DocType: Patient,Tobacco Past Use,Použití tabáku v minulosti
 DocType: Sales Invoice Item,Brand Name,Jméno značky
 DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
@@ -1902,7 +1903,7 @@
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Dovolená úspěšně přidělena {0}
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Žádné položky k balení
 DocType: Shipping Rule Condition,From Value,Od hodnoty
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +581,Manufacturing Quantity is mandatory,Výrobní množství je povinné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586,Manufacturing Quantity is mandatory,Výrobní množství je povinné
 DocType: Employee Loan,Repayment Method,splácení Metoda
 DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Pokud je zaškrtnuto, domovská stránka bude výchozí bod skupina pro webové stránky"
 DocType: Quality Inspection Reading,Reading 4,Čtení 4
@@ -1915,7 +1916,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Stock Závazky
 DocType: Purchase Invoice,Supplier Warehouse,Dodavatel Warehouse
 DocType: Opportunity,Contact Mobile No,Kontakt Mobil
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +382,Select Company,Vyberte společnost
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +389,Select Company,Vyberte společnost
 ,Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Uživatel {0} nemá žádný výchozí POS profil. Zaškrtněte výchozí v řádku {1} pro tohoto uživatele.
 DocType: Student Group,Set 0 for no limit,Nastavte 0 pro žádný limit
@@ -1947,7 +1948,7 @@
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Platba Poptávka již existuje {0}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Náklady na vydaných položek
 DocType: Physician,Hospital,NEMOCNICE
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +384,Quantity must not be more than {0},Množství nesmí být větší než {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +385,Quantity must not be more than {0},Množství nesmí být větší než {0}
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Předchozí finanční rok není uzavřen
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Stáří (dny)
 DocType: Quotation Item,Quotation Item,Položka Nabídky
@@ -2006,7 +2007,7 @@
 apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +17,Stock Available,Skladem k dispozici
 DocType: Manufacturing Settings,Capacity Planning For (Days),Plánování kapacit Pro (dny)
 apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Procurement
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,None of the items have any change in quantity or value.,Žádný z těchto položek má žádnou změnu v množství nebo hodnotě.
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66,None of the items have any change in quantity or value.,Žádný z těchto položek má žádnou změnu v množství nebo hodnotě.
 apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Povinná oblast - Program
 DocType: Special Test Template,Result Component,Komponent výsledků
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Záruční reklamace
@@ -2041,7 +2042,7 @@
 DocType: Selling Settings,Selling Settings,Prodejní Nastavení
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Potvrďte akci
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Aukce online
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +98,Please specify either Quantity or Valuation Rate or both,"Uveďte prosím buď Množství nebo ocenění Cena, nebo obojí"
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,Please specify either Quantity or Valuation Rate or both,"Uveďte prosím buď Množství nebo ocenění Cena, nebo obojí"
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,Splnění
 apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Zobrazit Košík
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Marketingové náklady
@@ -2095,7 +2096,6 @@
 DocType: Asset,Gross Purchase Amount,Gross Částka nákupu
 apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Počáteční zůstatky
 DocType: Asset,Depreciation Method,odpisy Metoda
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +64,Offline,Offline
 DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Celkem Target
 DocType: Soil Texture,Sand Composition (%),Složení písku (%)
@@ -2109,7 +2109,7 @@
 DocType: Student Group Instructor,Student Group Instructor,Instruktor skupiny studentů
 DocType: Grant Application,Assessment  Mark (Out of 10),Známka hodnocení (z 10)
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile Žádné
-apps/erpnext/erpnext/setup/doctype/company/company.py +194,Main,Hlavní
+apps/erpnext/erpnext/setup/doctype/company/company.py +201,Main,Hlavní
 apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Varianta
 DocType: Naming Series,Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakcí
 DocType: Employee Attendance Tool,Employees HTML,zaměstnanci HTML
@@ -2138,7 +2138,7 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Duplicitní Pořadové číslo vstoupil k bodu {0}
 DocType: Shipping Rule Condition,A condition for a Shipping Rule,Podmínka pro pravidla dopravy
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,Prosím Vstupte
-apps/erpnext/erpnext/controllers/accounts_controller.py +467,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Nelze overbill k bodu {0} v řadě {1} více než {2}. Aby bylo možné přes-fakturace, je třeba nastavit při nákupu Nastavení"
+apps/erpnext/erpnext/controllers/accounts_controller.py +478,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Nelze overbill k bodu {0} v řadě {1} více než {2}. Aby bylo možné přes-fakturace, je třeba nastavit při nákupu Nastavení"
 apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Protokol údržby
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +234,Please set filter based on Item or Warehouse,Prosím nastavit filtr na základě výtisku nebo ve skladu
 DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnost tohoto balíčku. (Automaticky vypočítá jako součet čisté váhy položek)
@@ -2147,7 +2147,7 @@
 DocType: GL Entry,Credit Amount in Account Currency,Kreditní Částka v měně účtu
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +588,BOM {0} must be submitted,BOM {0} musí být předloženy
 DocType: Authorization Control,Authorization Control,Autorizace Control
-apps/erpnext/erpnext/controllers/buying_controller.py +309,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Řádek # {0}: Zamítnutí Warehouse je povinná proti zamítnuté bodu {1}
+apps/erpnext/erpnext/controllers/buying_controller.py +327,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Řádek # {0}: Zamítnutí Warehouse je povinná proti zamítnuté bodu {1}
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +808,Payment,Platba
 apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Warehouse {0} není propojen s žádným účtem, uveďte prosím účet v záznamu skladu nebo nastavte výchozí inventární účet ve firmě {1}."
 apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Správa objednávek
@@ -2184,7 +2184,7 @@
 apps/erpnext/erpnext/accounts/party.py +266,Billing currency must be equal to either default company's currency or party account currency,Měna fakturace se musí rovnat buď měně výchozí měny nebo měně stran účtu
 DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Označuje, že balíček je součástí této dodávky (Pouze návrhu)"
 DocType: Soil Texture,Loam,Hlína
-apps/erpnext/erpnext/controllers/accounts_controller.py +680,Row {0}: Due Date cannot be before posting date,Řádek {0}: K datu splatnosti nemůže být datum odeslání
+apps/erpnext/erpnext/controllers/accounts_controller.py +691,Row {0}: Due Date cannot be before posting date,Řádek {0}: K datu splatnosti nemůže být datum odeslání
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Učinit vstup platby
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Množství k bodu {0} musí být menší než {1}
 ,Sales Invoice Trends,Prodejní faktury Trendy
@@ -2275,9 +2275,9 @@
 DocType: Payment Reconciliation Payment,Reference Row,referenční Row
 DocType: Installation Note,Installation Time,Instalace Time
 DocType: Sales Invoice,Accounting Details,Účetní detaily
-apps/erpnext/erpnext/setup/doctype/company/company.js +84,Delete all the Transactions for this Company,Odstraňte všechny transakce pro tuto společnost
+apps/erpnext/erpnext/setup/doctype/company/company.js +112,Delete all the Transactions for this Company,Odstraňte všechny transakce pro tuto společnost
 DocType: Patient,O Positive,O pozitivní
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +195,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} není dokončen {2} Množství hotových výrobků ve výrobním procesu objednávky # {3}. Prosím aktualizujte provozní stav přes čas protokoly
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +200,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} není dokončen {2} Množství hotových výrobků ve výrobním procesu objednávky # {3}. Prosím aktualizujte provozní stav přes čas protokoly
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investice
 DocType: Issue,Resolution Details,Rozlišení Podrobnosti
 apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,alokace
@@ -2381,11 +2381,11 @@
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +122,Expense Claim is pending approval. Only the Expense Approver can update status.,Úhrada výdajů čeká na schválení. Pouze schalovatel výdajů může aktualizovat stav.
 DocType: Email Digest,New Expenses,Nové výdaje
 DocType: Purchase Invoice,Additional Discount Amount,Dodatečná sleva Částka
-DocType: Consultation,Patient Details,Podrobnosti pacienta
+DocType: Patient,Patient Details,Podrobnosti pacienta
 DocType: Patient,B Positive,B Pozitivní
-apps/erpnext/erpnext/controllers/accounts_controller.py +575,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Řádek # {0}: Množství musí být 1, když je položka investičního majetku. Prosím použít samostatný řádek pro vícenásobné Mn."
+apps/erpnext/erpnext/controllers/accounts_controller.py +586,"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 +288,Abbr can not be blank or space,Zkratka nemůže být prázdný znak nebo mezera
+apps/erpnext/erpnext/setup/doctype/company/company.py +295,Abbr can not be blank or space,Zkratka nemůže být prázdný znak nebo mezera
 DocType: Patient Medical Record,Patient Medical Record,Záznam pacienta
 apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Skupina na Non-Group
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Sportovní
@@ -2421,7 +2421,7 @@
 DocType: Item,Retain Sample,Zachovat vzorek
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Řádek {0}: From Time a na čas je povinná.
 DocType: Stock Reconciliation Item,Amount Difference,výše Rozdíl
-apps/erpnext/erpnext/stock/get_item_details.py +349,Item Price added for {0} in Price List {1},Položka Cena přidán pro {0} v Ceníku {1}
+apps/erpnext/erpnext/stock/get_item_details.py +354,Item Price added for {0} in Price List {1},Položka Cena přidán pro {0} v Ceníku {1}
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,"Prosím, zadejte ID zaměstnance z tohoto prodeje osoby"
 DocType: Territory,Classification of Customers by region,Rozdělení zákazníků podle krajů
 apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,Ve výrobě
@@ -2438,7 +2438,6 @@
 ,Production Analytics,výrobní Analytics
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,To je založeno na transakcích proti tomuto pacientovi. Podrobnosti viz časová osa níže
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +201,Cost Updated,Náklady Aktualizováno
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položek&gt; Značka
 DocType: Patient,Date of Birth,Datum narození
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,Bod {0} již byla vrácena
 DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiskální rok ** představuje finanční rok. Veškeré účetní záznamy a další významné transakce jsou sledovány proti ** fiskální rok **.
@@ -2452,7 +2451,7 @@
 DocType: Purchase Taxes and Charges,Deduct,Odečíst
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236,Job Description,Popis Práce
 DocType: Student Applicant,Applied,Aplikovaný
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +859,Re-open,Znovu otevřít
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +863,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
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Speciální znaky kromě ""-"". """", ""#"", a ""/"" není povoleno v pojmenování řady"
@@ -2473,6 +2472,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)
 DocType: Pricing Rule,Supplier,Dodavatel
+apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Zobrazit údaje o platbě
 DocType: Consultation,Consultation Time,Doba konzultace
 DocType: C-Form,Quarter,Čtvrtletí
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Různé výdaje
@@ -2505,7 +2505,6 @@
 apps/erpnext/erpnext/templates/includes/product_page.js +71,Cannot find a matching Item. Please select some other value for {0}.,Nelze najít odpovídající položku. Vyberte nějakou jinou hodnotu pro {0}.
 DocType: POS Profile,Taxes and Charges,Daně a poplatky
 DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která se Nakupuje, Prodává nebo Skladuje."
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosím, nastavte systém pro pojmenování zaměstnanců v oblasti lidských zdrojů&gt; Nastavení HR"
 apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Žádné další aktualizace
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,"Toto pokrývá všechny body, které jsou spojeny s tímto nastavením"
@@ -2533,7 +2532,7 @@
 apps/erpnext/erpnext/hr/doctype/daily_work_summary_settings/daily_work_summary_settings.py +17,There must be a default incoming Email Account enabled for this to work. Please setup a default incoming Email Account (POP/IMAP) and try again.,Musí existovat výchozí příchozí e-mailový účet povolen pro tuto práci. Prosím nastavit výchozí příchozí e-mailový účet (POP / IMAP) a zkuste to znovu.
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Program ve struktuře poplatků a studentské skupině {0} jsou různé.
 DocType: Fee Schedule,Receivable Account,Účet pohledávky
-apps/erpnext/erpnext/controllers/accounts_controller.py +597,Row #{0}: Asset {1} is already {2},Řádek # {0}: Asset {1} je již {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +608,Row #{0}: Asset {1} is already {2},Řádek # {0}: Asset {1} je již {2}
 DocType: Quotation Item,Stock Balance,Reklamní Balance
 apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Prodejní objednávky na platby
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,výkonný ředitel
@@ -2596,9 +2595,9 @@
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Ceník {0} je zakázána
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Řádek {0}: Dokončené Množství nemůže být více než {1} pro provoz {2}
 DocType: Manufacturing Settings,Allow Overtime,Povolit Přesčasy
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serializovaná položka {0} nemůže být aktualizována pomocí odsouhlasení akcií, použijte prosím položku Stock"
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serializovaná položka {0} nemůže být aktualizována pomocí odsouhlasení akcií, použijte prosím položku Stock"
 DocType: Training Event Employee,Training Event Employee,Vzdělávání zaměstnanců Event
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +976,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maximální počet vzorků - {0} lze zadat pro dávky {1} a položku {2}.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1009,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maximální počet vzorků - {0} lze zadat pro dávky {1} a položku {2}.
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Přidat časové úseky
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Sériová čísla požadované pro položky {1}. Poskytli jste {2}.
 DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuální ocenění
@@ -2639,7 +2638,6 @@
 apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Aktuální počet {0} / Čekací počet {1}
 DocType: Purchase Invoice,E-commerce GSTIN,E-commerce GSTIN
 DocType: Sales Order,Not Delivered,Ne vyhlášeno
-apps/erpnext/erpnext/controllers/buying_controller.py +422,Expected Date cannot be before Transaction Date,Předpokládaný datum nemůže být před datem transakce
 ,Bank Clearance Summary,Souhrn bankovního zúčtování
 apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest."
 DocType: Appraisal Goal,Appraisal Goal,Posouzení Goal
@@ -2649,7 +2647,7 @@
 DocType: Timesheet Detail,Costing Amount,Kalkulace Částka
 DocType: Student Admission Program,Application Fee,poplatek za podání žádosti
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,Submit Salary Slip,Odeslat výplatní pásce
-apps/erpnext/erpnext/controllers/selling_controller.py +133,Maxiumm discount for Item {0} is {1}%,Maxiumm sleva na položky {0} {1}%
+apps/erpnext/erpnext/controllers/selling_controller.py +136,Maxiumm discount for Item {0} is {1}%,Maxiumm sleva na položky {0} {1}%
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Dovoz hromadnou
 DocType: Sales Partner,Address & Contacts,Adresa a kontakty
 DocType: SMS Log,Sender Name,Jméno odesílatele
@@ -2702,7 +2700,7 @@
 DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Zadejte operací, provozní náklady a dávají jedinečnou operaci ne své operace."
 DocType: Water Analysis,Origin,Původ
 apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Tento dokument je nad hranicí {0} {1} pro položku {4}. Děláte si jiný {3} proti stejné {2}?
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1086,Please set recurring after saving,Prosím nastavte opakující se po uložení
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1138,Please set recurring after saving,Prosím nastavte opakující se po uložení
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +763,Select change amount account,Vybrat změna výše účet
 DocType: Purchase Invoice,Price List Currency,Ceník Měna
 DocType: Naming Series,User must always select,Uživatel musí vždy vybrat
@@ -2713,22 +2711,23 @@
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Peněžní tok z finanční
 DocType: Budget Account,Budget Account,rozpočet účtu
 DocType: Quality Inspection,Verified By,Verified By
-apps/erpnext/erpnext/setup/doctype/company/company.py +70,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nelze změnit výchozí měně společnosti, protože tam jsou stávající transakce. Transakce musí být zrušena, aby změnit výchozí měnu."
+apps/erpnext/erpnext/setup/doctype/company/company.py +77,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nelze změnit výchozí měně společnosti, protože tam jsou stávající transakce. Transakce musí být zrušena, aby změnit výchozí měnu."
 DocType: Grading Scale Interval,Grade Description,Grade Popis
 DocType: Stock Entry,Purchase Receipt No,Číslo příjmky
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Earnest Money
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,sledovatelnost
 DocType: Asset Maintenance Log,Actions performed,Akce byly provedeny
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +406,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +411,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
 DocType: Supplier Scorecard Scoring Standing,Employee,Zaměstnanec
 DocType: Asset Repair,Failure Date,Datum selhání
 DocType: Sample Collection,Collected Time,Shromážděný čas
+apps/erpnext/erpnext/config/healthcare.py +134,Test Sample.,Zkušební vzorek.
 DocType: Company,Sales Monthly History,Měsíční historie prodeje
 DocType: Asset Maintenance Task,Next Due Date,Další datum splatnosti
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Vyberte možnost Dávka
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +242,{0} {1} is fully billed,{0} {1} je plně fakturováno
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +48,Vital Signs,Známky života
+apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +47,Vital Signs,Známky života
 DocType: Training Event,End Time,End Time
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Aktivní Struktura Plat {0} nalezeno pro zaměstnance {1} pro uvedené termíny
 DocType: Payment Entry,Payment Deductions or Loss,Platební srážky nebo ztráta
@@ -2742,7 +2741,7 @@
 DocType: Rename Tool,File to Rename,Soubor k přejmenování
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},"Prosím, vyberte BOM pro položku v řádku {0}"
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Účet {0} neodpovídá společnosti {1} v účtu účtu: {2}
-apps/erpnext/erpnext/controllers/buying_controller.py +271,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
+apps/erpnext/erpnext/controllers/buying_controller.py +289,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
 DocType: Soil Texture,Sandy Loam,Sandy Loam
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí být zrušena před zrušením této prodejní objednávky
 DocType: POS Profile,Applicable for Users,Platí pro uživatele
@@ -2773,7 +2772,7 @@
 DocType: BOM Update Tool,BOM Update Tool,Nástroj pro aktualizaci kusovníku
 DocType: SG Creation Tool Course,Student Group Name,Jméno Student Group
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Vytváření poplatků
-apps/erpnext/erpnext/setup/doctype/company/company.js +62,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Ujistěte se, že opravdu chcete vymazat všechny transakce pro tuto společnost. Vaše kmenová data zůstanou, jak to je. Tuto akci nelze vrátit zpět."
+apps/erpnext/erpnext/setup/doctype/company/company.js +90,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Ujistěte se, že opravdu chcete vymazat všechny transakce pro tuto společnost. Vaše kmenová data zůstanou, jak to je. Tuto akci nelze vrátit zpět."
 DocType: Room,Room Number,Číslo pokoje
 apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Neplatná reference {0} {1}
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemůže být větší, než plánované množství ({2}), ve výrobní objednávce {3}"
@@ -2809,7 +2808,7 @@
 DocType: BOM,Show Operations,Zobrazit Operations
 ,Minutes to First Response for Opportunity,Zápisy do první reakce na příležitost
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Celkem Absent
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +823,Item or Warehouse for row {0} does not match Material Request,Položka nebo Warehouse na řádku {0} neodpovídá Materiál Poptávka
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +840,Item or Warehouse for row {0} does not match Material Request,Položka nebo Warehouse na řádku {0} neodpovídá Materiál Poptávka
 apps/erpnext/erpnext/config/stock.py +187,Unit of Measure,Měrná jednotka
 DocType: Fiscal Year,Year End Date,Datum Konce Roku
 DocType: Task Depends On,Task Depends On,Úkol je závislá na
@@ -2913,7 +2912,7 @@
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Vyberte lékaře ...
 DocType: Grant Application,Grant Application Details ,Podrobnosti o žádosti o grant
 DocType: Purchase Receipt Item,Recd Quantity,Recd Množství
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +59,Fee Records Created - {0},Fee Records Vytvořil - {0}
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Fee Records Vytvořil - {0}
 DocType: Asset Category Account,Asset Category Account,Asset Kategorie Account
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Nelze produkují více položku {0} než prodejní objednávky množství {1}
 apps/erpnext/erpnext/stock/doctype/item/item.js +360,Select Attribute Values,Vyberte hodnoty atributů
@@ -3009,12 +3008,12 @@
 DocType: Bin,Reserved Quantity,Vyhrazeno Množství
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Zadejte platnou e-mailovou adresu
 DocType: Volunteer Skill,Volunteer Skill,Dobrovolnické dovednosti
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +713,Please select an item in the cart,Vyberte prosím položku v košíku
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +720,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 +74,Arrear,nedoplatek
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Odpisy hodnoty v průběhu období
-apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,Bezbariérový šablona nesmí být výchozí šablonu
+apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,Bezbariérový šablona nesmí být výchozí šablonu
 DocType: Account,Income Account,Účet příjmů
 DocType: Payment Request,Amount in customer's currency,Částka v měně zákazníka
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +823,Delivery,Dodávka
@@ -3025,12 +3024,12 @@
 DocType: Appraisal Goal,Key Responsibility Area,Key Odpovědnost Area
 apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Student Šarže pomůže sledovat docházku, posudky a poplatků pro studenty"
 DocType: Payment Entry,Total Allocated Amount,Celková alokovaná částka
-apps/erpnext/erpnext/setup/doctype/company/company.py +140,Set default inventory account for perpetual inventory,Nastavte výchozí inventář pro trvalý inventář
+apps/erpnext/erpnext/setup/doctype/company/company.py +147,Set default inventory account for perpetual inventory,Nastavte výchozí inventář pro trvalý inventář
 DocType: Item Reorder,Material Request Type,Materiál Typ požadavku
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural Zápis do deníku na platy od {0} do {1}
 apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Odeslání e-mailu o revizi grantu
 apps/erpnext/erpnext/accounts/page/pos/pos.js +839,"LocalStorage is full, did not save","Místní úložiště je plné, nezachránil"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +90,Row {0}: UOM Conversion Factor is mandatory,Řádek {0}: UOM Konverzní faktor je povinné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +95,Row {0}: UOM Conversion Factor is mandatory,Řádek {0}: UOM Konverzní faktor je povinné
 apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Kapacita místností
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref
 DocType: Lab Test,LP-,LP-
@@ -3051,11 +3050,11 @@
 apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Trasa vede od průmyslu typu.
 apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Přejděte na Letterheads
 DocType: Item Supplier,Item Supplier,Položka Dodavatel
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1187,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 +1239,Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no"
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +874,Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
 apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Všechny adresy.
 DocType: Company,Stock Settings,Stock Nastavení
-apps/erpnext/erpnext/accounts/doctype/account/account.py +185,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojení je možné pouze tehdy, pokud tyto vlastnosti jsou stejné v obou záznamech. Je Group, Root Type, Company"
+apps/erpnext/erpnext/accounts/doctype/account/account.py +183,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojení je možné pouze tehdy, pokud tyto vlastnosti jsou stejné v obou záznamech. Je Group, Root Type, Company"
 DocType: Vehicle,Electric,Elektrický
 DocType: Task,% Progress,% Progress
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Zisk / ztráta z aktiv likvidaci
@@ -3070,7 +3069,6 @@
 apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,Není skladem
 DocType: Volunteer,Volunteer Skills,Dobrovolnické dovednosti
 DocType: Appraisal,HR User,HR User
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,POS?,POS?
 DocType: Purchase Invoice,Taxes and Charges Deducted,Daně a odečtené
 apps/erpnext/erpnext/hooks.py +142,Issues,Problémy
 apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Stav musí být jedním z {0}
@@ -3105,7 +3103,7 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
 DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
 apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Poplatek
-apps/erpnext/erpnext/setup/doctype/company/company.js +125,Update in progress. It might take a while.,Aktualizace probíhá. Může chvíli trvat.
+apps/erpnext/erpnext/setup/doctype/company/company.js +153,Update in progress. It might take a while.,Aktualizace probíhá. Může chvíli trvat.
 DocType: Vehicle Log,Fuel Qty,palivo Množství
 DocType: Production Order Operation,Planned Start Time,Plánované Start Time
 DocType: Course,Assessment,Posouzení
@@ -3204,7 +3202,7 @@
 DocType: Asset,In Maintenance,V údržbě
 DocType: Purchase Invoice,Overdue,Zpožděný
 DocType: Account,Stock Received But Not Billed,Sklad nepřijali Účtovaný
-apps/erpnext/erpnext/accounts/doctype/account/account.py +86,Root Account must be a group,Root účet musí být skupina
+apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root Account must be a group,Root účet musí být skupina
 DocType: Consultation,Drug Prescription,Předepisování léků
 DocType: Fees,FEE.,POPLATEK.
 DocType: Employee Loan,Repaid/Closed,Splacena / Zavřeno
@@ -3229,7 +3227,7 @@
 DocType: Stock Entry,Material Transfer for Manufacture,Materiál Přenos: Výroba
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Sleva v procentech lze použít buď proti Ceníku nebo pro všechny Ceníku.
 DocType: Subscription,Half-yearly,Pololetní
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +406,Accounting Entry for Stock,Účetní položka na skladě
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407,Accounting Entry for Stock,Účetní položka na skladě
 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
@@ -3250,7 +3248,7 @@
 DocType: Item Group,Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky
 DocType: BOM,Item UOM,Položka UOM
 DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Částka daně po slevě Částka (Company měny)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +155,Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +160,Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
 DocType: Cheque Print Template,Primary Settings,primární Nastavení
 DocType: Purchase Invoice,Select Supplier Address,Vybrat Dodavatel Address
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Přidejte Zaměstnanci
@@ -3265,7 +3263,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 +714,Can only make payment against unbilled {0},Lze provést pouze platbu proti nevyfakturované {0}
-apps/erpnext/erpnext/controllers/selling_controller.py +98,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
+apps/erpnext/erpnext/controllers/selling_controller.py +101,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
 DocType: Volunteer,Volunteer,Dobrovolník
 DocType: Stock Entry,Subcontract,Subdodávka
 apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,"Prosím, zadejte {0} jako první"
@@ -3294,14 +3292,13 @@
 DocType: Patient,Personal and Social History,Osobní a sociální historie
 apps/erpnext/erpnext/education/doctype/guardian/guardian.py +52,User {0} created,Uživatel {0} byl vytvořen
 DocType: Fee Schedule,Fee Breakup for each student,Rozdělení poplatků za každého studenta
-apps/erpnext/erpnext/controllers/accounts_controller.py +520,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celková záloha ({0}) na objednávku {1} nemůže být větší než celkový součet ({2})
+apps/erpnext/erpnext/controllers/accounts_controller.py +531,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celková záloha ({0}) na objednávku {1} nemůže být větší než celkový součet ({2})
 DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Vyberte měsíční výplatou na nerovnoměrně distribuovat cílů napříč měsíců.
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Změnit kód
 DocType: Purchase Invoice Item,Valuation Rate,Ocenění
 DocType: Stock Reconciliation,SR/,SR /
 DocType: Vehicle,Diesel,motorová nafta
-apps/erpnext/erpnext/stock/get_item_details.py +381,Price List Currency not selected,Ceníková Měna není zvolena
-apps/erpnext/erpnext/config/healthcare.py +46,Results,výsledky
+apps/erpnext/erpnext/stock/get_item_details.py +386,Price List Currency not selected,Ceníková Měna není zvolena
 ,Student Monthly Attendance Sheet,Student měsíční návštěvnost Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Pravidlo plavby platí pouze pro prodej
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Zaměstnanec {0} již požádal o {1} mezi {2} a {3}
@@ -3331,9 +3328,10 @@
 DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Registrace do programu Student Tool
 apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},Datum zahájení by mělo být menší než datum ukončení úkolu {0}
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Jméno nebo e-mail je povinné
+DocType: Instructor,Instructor Log,Příručka instruktora
 DocType: Purchase Order Item,Returned Qty,Vrácené Množství
 DocType: Student,Exit,Východ
-apps/erpnext/erpnext/accounts/doctype/account/account.py +158,Root Type is mandatory,Root Type je povinné
+apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Root Type je povinné
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Instalace předvoleb se nezdařila
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} v současné době disponuje {1} hodnotící tabulkou dodavatelů a RFQ tohoto dodavatele by měla být vydána s opatrností.
 DocType: Chapter,Non Profit Manager,Neziskový manažer
@@ -3357,6 +3355,7 @@
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Dávka je povinná v řádku {0}
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané
 DocType: Payment Entry,Pay,Zaplatit
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,"Prosím, nastavte systém pro pojmenování instruktorů ve vzdělání&gt; Nastavení vzdělávání"
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Chcete-li datetime
 apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Protokoly pro udržení stavu doručení sms
 DocType: Accounts Settings,Make Payment via Journal Entry,Provést platbu přes Journal Entry
@@ -3379,15 +3378,15 @@
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Změna pořadí Level
 DocType: Company,Chart Of Accounts Template,Účtový rozvrh šablony
 DocType: Attendance,Attendance Date,Účast Datum
-apps/erpnext/erpnext/stock/get_item_details.py +345,Item Price updated for {0} in Price List {1},Položka Cena aktualizován pro {0} v Ceníku {1}
+apps/erpnext/erpnext/stock/get_item_details.py +350,Item Price updated for {0} in Price List {1},Položka Cena aktualizován pro {0} v Ceníku {1}
 DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +130,Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu
+apps/erpnext/erpnext/accounts/doctype/account/account.py +128,Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu
 DocType: Purchase Invoice Item,Accepted Warehouse,Schválený sklad
 DocType: Bank Reconciliation Detail,Posting Date,Datum zveřejnění
 DocType: Item,Valuation Method,Metoda ocenění
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Půldenní
 DocType: Sales Invoice,Sales Team,Prodejní tým
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +85,Duplicate entry,Duplicitní záznam
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,Duplicate entry,Duplicitní záznam
 DocType: Program Enrollment Tool,Get Students,Získat studenty
 DocType: Serial No,Under Warranty,V rámci záruky
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +515,[Error],[Chyba]
@@ -3405,6 +3404,7 @@
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Pořadové číslo {0} neexistuje
 DocType: Sales Invoice Item,Customer Warehouse (Optional),Zákaznický sklad (volitelně)
 DocType: Pricing Rule,Discount Percentage,Sleva v procentech
+apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Vyhrazeno pro uzavření smlouvy
 DocType: Payment Reconciliation Invoice,Invoice Number,Číslo faktury
 DocType: Shopping Cart Settings,Orders,Objednávky
 DocType: Employee Leave Approver,Leave Approver,Schvalovatel absenece
@@ -3433,7 +3433,8 @@
 apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Průměrné Míra prodejních cen
 DocType: Production Plan Sales Order,Salse Order Date,Salse Datum objednávky
 DocType: Salary Component,Salary Component,plat Component
-apps/erpnext/erpnext/accounts/utils.py +492,Payment Entries {0} are un-linked,Platební Příspěvky {0} jsou un-spojený
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položek&gt; Značka
+apps/erpnext/erpnext/accounts/utils.py +495,Payment Entries {0} are un-linked,Platební Příspěvky {0} jsou un-spojený
 DocType: GL Entry,Voucher No,Voucher No
 ,Lead Owner Efficiency,Vedoucí účinnost vlastníka
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +195,Most Popular,Nejoblíbenější
@@ -3468,7 +3469,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 +396,{0} {1} is cancelled or closed,{0} {1} je zrušen nebo zavřené
+apps/erpnext/erpnext/controllers/buying_controller.py +414,{0} {1} is cancelled or closed,{0} {1} je zrušen nebo zavřené
 DocType: Asset,Calculate Depreciation,Vypočítat odpisy
 DocType: Delivery Note,Track this Delivery Note against any Project,Sledovat tento dodacím listu proti jakémukoli projektu
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Čistý peněžní tok z investiční
@@ -3480,6 +3481,7 @@
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Odpisy vypadl v důsledku nakládání s majetkem
 DocType: Member,Member,Člen
 apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Správa adres
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Prosím, nastavte číselnou sérii pro Účast přes Nastavení&gt; Číslovací série"
 DocType: Pricing Rule,Item Code,Kód položky
 DocType: Production Planning Tool,Create Production Orders,Vytvoření výrobní zakázky
 DocType: Serial No,Warranty / AMC Details,Záruka / AMC Podrobnosti
@@ -3510,7 +3512,7 @@
 DocType: Asset,Double Declining Balance,Double degresivní
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Uzavřená objednávka nemůže být zrušen. Otevřít zrušit.
 DocType: Student Guardian,Father,Otec
-apps/erpnext/erpnext/controllers/accounts_controller.py +606,'Update Stock' cannot be checked for fixed asset sale,"""Aktualizace Sklad"" nemohou být zaškrtnuty na prodej dlouhodobého majetku"
+apps/erpnext/erpnext/controllers/accounts_controller.py +617,'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
@@ -3522,8 +3524,8 @@
 DocType: Sales Order,Fully Delivered,Plně Dodáno
 DocType: Lead,Lower Income,S nižšími příjmy
 DocType: Restaurant Order Entry,Current Order,Aktuální objednávka
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +174,Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Rozdíl účet musí být typu aktiv / Odpovědnost účet, protože to Reklamní Smíření je Entry Otevření"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +179,Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Rozdíl účet musí být typu aktiv / Odpovědnost účet, protože to Reklamní Smíření je Entry Otevření"
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Zaplacené částky nemůže být větší než Výše úvěru {0}
 apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Přejděte na položku Programy
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},"Řádek {0} # Přidělená částka {1} nemůže být vyšší než částka, která nebyla požadována. {2}"
@@ -3598,7 +3600,7 @@
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Vytvořte poplatky
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Celkové pořizovací náklady (přes nákupní faktury)
 DocType: Training Event,Start Time,Start Time
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +399,Select Quantity,Zvolte množství
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +400,Select Quantity,Zvolte množství
 DocType: Customs Tariff Number,Customs Tariff Number,Celního sazebníku
 DocType: Patient Appointment,Patient Appointment,Setkání pacienta
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Schválení role nemůže být stejná jako role pravidlo se vztahuje na
@@ -3606,8 +3608,9 @@
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +828,Get Suppliers By,Získejte dodavatele
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{0} nebyl nalezen pro položku {1}
 apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Přejděte na Kurzy
+DocType: Accounts Settings,Show Inclusive Tax In Print,Zobrazit inkluzivní daň v tisku
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Zpráva byla odeslána
-apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Account with child nodes cannot be set as ledger,Účet s podřízené uzly nelze nastavit jako hlavní knihy
+apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Account with child nodes cannot be set as ledger,Účet s podřízené uzly nelze nastavit jako hlavní knihy
 DocType: C-Form,II,II
 DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou je ceníková měna převedena na základní měnu zákazníka"
 DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá částka (Company Měna)
@@ -3718,6 +3721,7 @@
 DocType: Company,Asset Depreciation Cost Center,Asset Odpisy nákladového střediska
 DocType: Sales Order Item,Sales Order Date,Prodejní objednávky Datum
 DocType: Sales Invoice Item,Delivered Qty,Dodává Množství
+apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total Excl. Tax,Celkem Excl. Daň
 DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Zda zaškrtnuto, vypíše včetně stromu každé výrobní položky v požadavku materiálu."
 DocType: Assessment Plan,Assessment Plan,Plan Assessment
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Zákazník {0} je vytvořen.
@@ -3739,14 +3743,14 @@
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Noví zákazníci
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +75,Gross Profit %,Hrubý Zisk %
 DocType: Appraisal Goal,Weightage (%),Weightage (%)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +489,Change POS Profile,Změňte profil POS
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +496,Change POS Profile,Změňte profil POS
 DocType: Bank Reconciliation Detail,Clearance Date,Výprodej Datum
 apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Zpráva o hodnocení
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Gross Částka nákupu je povinná
 DocType: Lead,Address Desc,Popis adresy
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +102,Party is mandatory,Party je povinná
 DocType: Journal Entry,JV-,JV-
-apps/erpnext/erpnext/controllers/accounts_controller.py +687,Rows with duplicate due dates in other rows were found: {list},V jiných řádcích byly nalezeny řádky s duplicitními daty: {list}
+apps/erpnext/erpnext/controllers/accounts_controller.py +698,Rows with duplicate due dates in other rows were found: {list},V jiných řádcích byly nalezeny řádky s duplicitními daty: {list}
 DocType: Topic,Topic Name,Název tématu
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena
 apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Vyberte podstatu svého podnikání.
@@ -3761,9 +3765,10 @@
 No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Single pro výsledky, které vyžadují pouze jeden vstup, výsledek UOM a normální hodnota <br> Sloučenina pro výsledky, které vyžadují více vstupních polí s odpovídajícími názvy událostí, výsledky UOM a normální hodnoty <br> Popisné pro testy, které mají více komponent výsledků a odpovídající pole pro vyplnění výsledků. <br> Seskupeny pro testovací šablony, které jsou skupinou dalších zkušebních šablon. <br> Žádný výsledek pro testy bez výsledků. Také není vytvořen žádný laboratorní test. např. Podtřídy pro seskupené výsledky."
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +75,Row #{0}: Duplicate entry in References {1} {2},Řádek # {0}: Duplicitní záznam v odkazu {1} {2}
 apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny."
+apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,Jako zkoušející
 DocType: Asset Movement,Source Warehouse,Zdroj Warehouse
 DocType: Installation Note,Installation Date,Datum instalace
-apps/erpnext/erpnext/controllers/accounts_controller.py +585,Row #{0}: Asset {1} does not belong to company {2},Řádek # {0}: {1} Asset nepatří do společnosti {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +596,Row #{0}: Asset {1} does not belong to company {2},Řádek # {0}: {1} Asset nepatří do společnosti {2}
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Byla vytvořena prodejní faktura {0}
 DocType: Employee,Confirmation Date,Potvrzení Datum
 DocType: C-Form,Total Invoiced Amount,Celkem Fakturovaná částka
@@ -3773,7 +3778,7 @@
 DocType: Supplier Scorecard Scoring Standing,Standing Name,Stálé jméno
 DocType: Stock Entry,Customer or Supplier Details,Zákazníka nebo dodavatele Podrobnosti
 DocType: Employee Loan Application,Required by Date,Vyžadováno podle data
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +222,Closing Balance (Dr - Cr),Závěrečný zůstatek (Dr - Cr)
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +229,Closing Balance (Dr - Cr),Závěrečný zůstatek (Dr - Cr)
 DocType: Lead,Lead Owner,Majitel leadu
 DocType: Bin,Requested Quantity,Požadované množství
 DocType: Patient,Marital Status,Rodinný stav
@@ -3787,13 +3792,13 @@
 apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Více variant
 DocType: Sales Invoice,Against Income Account,Proti účet příjmů
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% dodáno
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +96,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množství {1} nemůže být nižší než minimální Objednané množství {2} (definované v bodu).
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +97,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množství {1} nemůže být nižší než minimální Objednané množství {2} (definované v bodu).
 DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Měsíční Distribution Procento
 apps/erpnext/erpnext/hub_node/page/hub/hub.js +90,Please login as another user.,Přihlaste se jako další uživatel.
 DocType: Territory,Territory Targets,Území Cíle
 DocType: Soil Analysis,Ca/Mg,Ca / Mg
 DocType: Delivery Note,Transporter Info,Transporter Info
-apps/erpnext/erpnext/accounts/utils.py +499,Please set default {0} in Company {1},Prosím nastavit výchozí {0} ve firmě {1}
+apps/erpnext/erpnext/accounts/utils.py +502,Please set default {0} in Company {1},Prosím nastavit výchozí {0} ve firmě {1}
 DocType: Cheque Print Template,Starting position from top edge,Výchozí poloha od horního okraje
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +31,Same supplier has been entered multiple times,Stejný dodavatel byl zadán vícekrát
 apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Hrubý zisk / ztráta
@@ -3812,7 +3817,7 @@
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Rate
 DocType: Asset,Journal Entry for Scrap,Zápis do deníku do šrotu
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list"
-apps/erpnext/erpnext/accounts/utils.py +469,Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený
+apps/erpnext/erpnext/accounts/utils.py +472,Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený
 apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Záznam všech sdělení typu e-mail, telefon, chat, návštěvy, atd"
 DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Hodnocení skóre dodavatele skóre
 DocType: Manufacturer,Manufacturers used in Items,Výrobci používané v bodech
@@ -3834,11 +3839,11 @@
 apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Rychlost: {0}
 DocType: Company,Exchange Gain / Loss Account,Exchange Zisk / ztráty
 apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Zaměstnanců a docházky
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Purpose must be one of {0},Cíl musí být jedním z {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Purpose must be one of {0},Cíl musí být jedním z {0}
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +116,Fill the form and save it,Vyplňte formulář a uložte jej
 DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,"Stáhněte si aktuální stav stav zásob, který obsahuje všechny položky"
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum Community
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Aktuální množství na skladě
+apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Aktuální množství na skladě
 DocType: Homepage,"URL for ""All Products""",URL pro &quot;všechny produkty&quot;
 DocType: Leave Application,Leave Balance Before Application,Stav absencí před požadavkem
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46,Send SMS,Pošlete SMS
@@ -3954,7 +3959,7 @@
 DocType: Item,Default BOM,Výchozí BOM
 DocType: Project,Total Billed Amount (via Sales Invoices),Celková fakturační částka (prostřednictvím prodejních faktur)
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Částka pro debetní poznámku
-apps/erpnext/erpnext/setup/doctype/company/company.js +60,Please re-type company name to confirm,Prosím re-typ název společnosti na potvrzení
+apps/erpnext/erpnext/setup/doctype/company/company.js +88,Please re-type company name to confirm,Prosím re-typ název společnosti na potvrzení
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Total Outstanding Amt,Celkem Vynikající Amt
 DocType: Journal Entry,Printing Settings,Tisk Nastavení
 DocType: Employee Advance,Advance Account,Advance účet
@@ -3975,7 +3980,7 @@
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Studentská adresa
 DocType: Purchase Invoice,Price List Exchange Rate,Katalogová cena Exchange Rate
-apps/erpnext/erpnext/accounts/doctype/account/account.py +253,Account Number {0} already used in account {1},Číslo účtu {0} již použito v účtu {1}
+apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},Číslo účtu {0} již použito v účtu {1}
 DocType: POS Profile,POS Profile Name,Název profilu POS
 DocType: Purchase Invoice Item,Rate,Cena
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Internovat
@@ -4011,7 +4016,7 @@
 apps/erpnext/erpnext/accounts/page/pos/pos.js +1943,Enter value must be positive,Zadejte hodnota musí být kladná
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,Všechny území
 DocType: Purchase Invoice,Items,Položky
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +28,Student is already enrolled.,Student je již zapsáno.
+apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,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 +240,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
 DocType: Product Bundle Item,Product Bundle Item,Product Bundle Item
@@ -4060,6 +4065,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Rostliny a strojní vybavení
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po slevě Částka
 DocType: Daily Work Summary Settings,Daily Work Summary Settings,Každodenní práci Souhrnné Nastavení
+apps/erpnext/erpnext/controllers/buying_controller.py +457,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á
@@ -4126,7 +4132,7 @@
 DocType: Education Settings,Education Manager,Správce vzdělávání
 DocType: Production Planning Tool,Production Planning Tool,Plánovcí rozvrh
 DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Minimální délka mezi jednotlivými rostlinami v terénu pro optimální růst
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Doručená položka {0} nemůže být aktualizována s využitím skladového uspokojení, místo toho použijte položku Sklad"
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","Doručená položka {0} nemůže být aktualizována s využitím skladového uspokojení, místo toho použijte položku Sklad"
 DocType: Quality Inspection,Report Date,Datum Reportu
 DocType: Student,Middle Name,Prostřední jméno
 DocType: C-Form,Invoices,Faktury
@@ -4135,7 +4141,7 @@
 DocType: Job Opening,Job Title,Název pozice
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.","{0} znamená, že {1} neposkytne citát, ale byly citovány všechny položky \. Aktualizace stavu nabídky RFQ."
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +971,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximální vzorky - {0} již byly zadány v dávce {1} a položce {2} v dávce {3}.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1004,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Maximální vzorky - {0} již byly zadány v dávce {1} a položce {2} v dávce {3}.
 DocType: Manufacturing Settings,Update BOM Cost Automatically,Aktualizovat cenu BOM automaticky
 DocType: Lab Test,Test Name,Testovací jméno
 apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Vytvořit uživatele
@@ -4154,13 +4160,13 @@
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Zrušte faktuře {0} první
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-mailová adresa musí být jedinečná, již existuje pro {0}"
 DocType: Serial No,AMC Expiry Date,AMC Datum vypršení platnosti
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Receipt,Příjem
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +869,Receipt,Příjem
 ,Sales Register,Sales Register
 DocType: Daily Work Summary Settings Company,Send Emails At,Posílat e-maily At
 DocType: Quotation,Quotation Lost Reason,Důvod ztráty nabídky
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,Transaction reference no {0} dated {1},Referenční transakce no {0} ze dne {1}
 apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Není nic upravovat.
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +476,Form View,Zobrazení formuláře
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +483,Form View,Zobrazení formuláře
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Shrnutí pro tento měsíc a probíhajícím činnostem
 apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Přidejte uživatele do vaší organizace, kromě vás."
 DocType: Customer Group,Customer Group Name,Zákazník Group Name
@@ -4210,7 +4216,7 @@
 DocType: Expense Claim,More Details,Další podrobnosti
 DocType: Supplier Quotation,Supplier Address,Dodavatel Address
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Rozpočet na účet {1} proti {2} {3} je {4}. To bude přesahovat o {5}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +689,Row {0}# Account must be of type 'Fixed Asset',Řádek {0} # účet musí být typu &quot;Fixed Asset&quot;
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695,Row {0}# Account must be of type 'Fixed Asset',Řádek {0} # účet musí být typu &quot;Fixed Asset&quot;
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Out Množství
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,a zrušeno Zakázáno v
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Série je povinné
@@ -4238,6 +4244,7 @@
 DocType: Payment Reconciliation,To Invoice Date,Chcete-li data vystavení faktury
 DocType: Supplier,Contact HTML,Kontakt HTML
 DocType: Disease,Treatment Period,Doba léčby
+apps/erpnext/erpnext/controllers/buying_controller.py +169,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
 DocType: Landed Cost Voucher,LCV,LCV
@@ -4277,7 +4284,7 @@
 DocType: Delivery Stop,Select/Unselect Delivery Notes,Zvolte / zrušte výběr poznámky k doručení
 DocType: Offer Letter,Awaiting Response,Čeká odpověď
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Výše
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1375,Total Amount {0},Celková částka {0}
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1383,Total Amount {0},Celková částka {0}
 apps/erpnext/erpnext/controllers/item_variant.py +301,Invalid attribute {0} {1},Neplatný atribut {0} {1}
 DocType: Supplier,Mention if non-standard payable account,Uvedete-li neštandardní splatný účet
 apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Vyberte jinou skupinu hodnocení než skupinu Všechny skupiny
@@ -4287,7 +4294,7 @@
 DocType: Agriculture Analysis Criteria,Water Analysis,Analýza vody
 DocType: Chapter,Region,Kraj
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Volitelné. Toto nastavení bude použito k filtrování v různých transakcí.
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +108,Negative Valuation Rate is not allowed,Negativní ocenění není povoleno
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110,Negative Valuation Rate is not allowed,Negativní ocenění není povoleno
 DocType: Holiday List,Weekly Off,Týdenní Off
 apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Znovu načtení propojené analýzy
 DocType: Fiscal Year,"For e.g. 2012, 2012-13","Pro např 2012, 2012-13"
@@ -4310,7 +4317,7 @@
 apps/erpnext/erpnext/stock/doctype/batch/batch.js +64,Split,Rozdělit
 DocType: GL Entry,Is Advance,Je Zálohová
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinná
-apps/erpnext/erpnext/controllers/buying_controller.py +153,Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
+apps/erpnext/erpnext/controllers/buying_controller.py +156,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: Sales Team,Contact No.,Kontakt Číslo
@@ -4346,7 +4353,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 +94,Commission on Sales,Provize z prodeje
 DocType: Offer Letter Term,Value / Description,Hodnota / Popis
-apps/erpnext/erpnext/controllers/accounts_controller.py +609,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Řádek # {0}: Asset {1} nemůže být předložen, je již {2}"
+apps/erpnext/erpnext/controllers/accounts_controller.py +620,"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
@@ -4361,7 +4368,7 @@
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Neplatný množství uvedené na položku {0}. Množství by mělo být větší než 0.
 DocType: Company,Default Employee Advance Account,Výchozí účet předplatného pro zaměstnance
 apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Žádosti o dovolenou.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +166,Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán
+apps/erpnext/erpnext/accounts/doctype/account/account.py +164,Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán
 DocType: Vehicle,Last Carbon Check,Poslední Carbon Check
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Výdaje na právní služby
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Vyberte množství v řadě
@@ -4376,18 +4383,16 @@
 DocType: Email Digest,Open Notifications,Otevřené Oznámení
 DocType: Payment Entry,Difference Amount (Company Currency),Rozdíl Částka (Company měna)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Přímé náklady
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,"Prosím, nastavte systém pro pojmenování instruktorů ve vzdělání&gt; Nastavení vzdělávání"
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Nový zákazník Příjmy
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Cestovní výdaje
 DocType: Maintenance Visit,Breakdown,Rozbor
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Přidání vlastního pole Subscription do doctype {0}
-apps/erpnext/erpnext/controllers/accounts_controller.py +789,Account: {0} with currency: {1} can not be selected,Účet: {0} s měnou: {1} nelze vybrat
+apps/erpnext/erpnext/controllers/accounts_controller.py +800,Account: {0} with currency: {1} can not be selected,Účet: {0} s měnou: {1} nelze vybrat
 DocType: Purchase Receipt Item,Sample Quantity,Množství vzorku
 DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Aktualizujte náklady na BOM automaticky pomocí programu Plánovač, založený na nejnovější hodnotící sazbě / ceníku / posledním nákupu surovin."
 DocType: Bank Reconciliation Detail,Cheque Date,Šek Datum
 apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2}
-DocType: Program Enrollment Tool,Student Applicants,Student Žadatelé
-apps/erpnext/erpnext/setup/doctype/company/company.js +77,Successfully deleted all transactions related to this company!,Úspěšně vypouští všechny transakce související s tímto společnosti!
+apps/erpnext/erpnext/setup/doctype/company/company.js +105,Successfully deleted all transactions related to this company!,Úspěšně vypouští všechny transakce související s tímto společnosti!
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Stejně jako u Date
 DocType: Appraisal,HR,HR
 DocType: Program Enrollment,Enrollment Date,zápis Datum
@@ -4447,7 +4452,7 @@
 ,Territory Target Variance Item Group-Wise,Území Cílová Odchylka Item Group-Wise
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Všechny skupiny zákazníků
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,nahromaděné za měsíc
-apps/erpnext/erpnext/controllers/accounts_controller.py +750,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možná není vytvořen záznam směnného kurzu pro {1} na {2}.
+apps/erpnext/erpnext/controllers/accounts_controller.py +761,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možná není vytvořen záznam směnného kurzu pro {1} na {2}.
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +41,Tax Template is mandatory.,Daňová šablona je povinné.
 apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje
 DocType: Purchase Invoice Item,Price List Rate (Company Currency),Ceník Rate (Company měny)
@@ -4477,7 +4482,7 @@
 DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Položka Wise Tax Detail
 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 +966,Supplier Quotation,Dodavatel Nabídka
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +970,Supplier Quotation,Dodavatel Nabídka
 DocType: Quotation,In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku."
 apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},Množství ({0}) nemůže být zlomek v řádku {1}
 DocType: Consultation,C-,C-
@@ -4506,7 +4511,7 @@
 DocType: Program Enrollment Tool,Enroll Students,zapsat studenti
 DocType: Lab Test,Approved Date,Datum schválení
 apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standardní prodejní
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +143,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +148,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
 DocType: Serial No,Out of Warranty,Out of záruky
 DocType: BOM Update Tool,Replace,Vyměnit
 apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Nenašli se žádné produkty.
@@ -4537,14 +4542,14 @@
 apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Vynikající Amt
 DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.
 DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Zásoby Starší než [dny]
-apps/erpnext/erpnext/controllers/accounts_controller.py +579,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Řádek # {0}: Prostředek je povinné pro dlouhodobého majetku nákupu / prodeji
+apps/erpnext/erpnext/controllers/accounts_controller.py +590,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Řádek # {0}: Prostředek je povinné pro dlouhodobého majetku nákupu / prodeji
 DocType: Asset Maintenance Team,Maintenance Team Name,Název týmu údržby
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Pokud dva nebo více pravidla pro tvorbu cen se nacházejí na základě výše uvedených podmínek, priorita je aplikována. Priorita je číslo od 0 do 20, zatímco výchozí hodnota je nula (prázdný). Vyšší číslo znamená, že bude mít přednost, pokud existuje více pravidla pro tvorbu cen se za stejných podmínek."
 apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiskální rok: {0} neexistuje
 DocType: Currency Exchange,To Currency,Chcete-li měny
 DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Nechte následující uživatelé schválit Žádost o dovolenou.
 apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Druhy výdajů nároku.
-apps/erpnext/erpnext/controllers/selling_controller.py +144,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Prodejní cena pro položku {0} je nižší než její {1}. Míra prodeje by měla být nejméně {2}
+apps/erpnext/erpnext/controllers/selling_controller.py +147,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Prodejní cena pro položku {0} je nižší než její {1}. Míra prodeje by měla být nejméně {2}
 DocType: Item,Taxes,Daně
 DocType: Purchase Invoice Item,Weight Per Unit,Hmotnost na jednotku
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Uhrazené a nedoručené
@@ -4580,6 +4585,7 @@
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"Can not filter based on Voucher No, if grouped by Voucher","Nelze filtrovat na základě poukazu ne, pokud seskupeny podle poukazu"
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +916,Make Supplier Quotation,Vytvořit nabídku dodavatele
 DocType: Quality Inspection,Incoming,Přicházející
+apps/erpnext/erpnext/setup/doctype/company/company.js +69,Default tax templates for sales and purchase are created.,Výchozí daňové šablony pro prodej a nákup jsou vytvořeny.
 apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +47,Assessment Result record {0} already exists.,Výsledky hodnocení {0} již existuje.
 DocType: BOM,Materials Required (Exploded),Potřebný materiál (Rozložený)
 apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',"Nastavte filtr společnosti prázdný, pokud je Skupina By je &#39;Company&#39;"
@@ -4587,7 +4593,7 @@
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Řádek # {0}: Výrobní číslo {1} neodpovídá {2} {3}
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,pro generování opakování
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Casual Leave
-apps/erpnext/erpnext/config/healthcare.py +138,Lab Test UOM.,Laboratorní test UOM.
+apps/erpnext/erpnext/config/healthcare.py +139,Lab Test UOM.,Laboratorní test UOM.
 DocType: Agriculture Task,End Day,Den konce
 DocType: Batch,Batch ID,Šarže ID
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Poznámka: {0}
@@ -4639,7 +4645,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} předměty vyrobené
 apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Další informace
 DocType: Cheque Print Template,Distance from top edge,Vzdálenost od horního okraje
-apps/erpnext/erpnext/stock/get_item_details.py +360,Price List {0} is disabled or does not exist,Ceníková cena {0} je zakázáno nebo neexistuje
+apps/erpnext/erpnext/stock/get_item_details.py +365,Price List {0} is disabled or does not exist,Ceníková cena {0} je zakázáno nebo neexistuje
 DocType: Purchase Invoice,Return,Zpáteční
 DocType: Production Order Operation,Production Order Operation,Výrobní zakázka Operace
 DocType: Pricing Rule,Disable,Zakázat
@@ -4660,7 +4666,7 @@
 DocType: Homepage,Tag Line,tag linka
 DocType: Fee Component,Fee Component,poplatek Component
 apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Fleet management
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +964,Add items from,Přidat položky z
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +968,Add items from,Přidat položky z
 apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Plodiny a půdy
 DocType: Cheque Print Template,Regular,Pravidelný
 DocType: Fertilizer,Density (if liquid),Hustota (pokud je kapalina)
@@ -4684,14 +4690,14 @@
 DocType: Payment Entry,Paid Amount,Uhrazené částky
 apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Prozkoumejte prodejní cyklus
 DocType: Assessment Plan,Supervisor,Dozorce
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +70,Online,Online
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +867,Retention Stock Entry,Retention Stock Entry
 ,Available Stock for Packing Items,K dispozici skladem pro balení položek
 DocType: Item Variant,Item Variant,Položka Variant
 DocType: Assessment Result Tool,Assessment Result Tool,Assessment Tool Výsledek
+apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,Jako školitel
 DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
 apps/erpnext/erpnext/accounts/page/pos/pos.js +886,Submitted orders can not be deleted,Předložené objednávky nelze smazat
-apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
+apps/erpnext/erpnext/accounts/doctype/account/account.py +114,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Řízení kvality
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Item {0} byl zakázán
 DocType: Project,Total Billable Amount (via Timesheets),Celková fakturační částka (prostřednictvím časových lístků)
@@ -4703,6 +4709,7 @@
 DocType: Opening Invoice Creation Tool,Purchase,Nákup
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Zůstatek Množství
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Cíle nemůže být prázdný
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15,Enrolling students,Přijímání studentů
 DocType: Item Group,Parent Item Group,Parent Item Group
 DocType: Appointment Type,Appointment Type,Typ schůzky
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} pro {1}
@@ -4736,10 +4743,11 @@
 DocType: Academic Term,Term Start Date,Termín Datum zahájení
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +242,Please find attached {0} #{1},V příloze naleznete {0} # {1}
-apps/erpnext/erpnext/controllers/accounts_controller.py +701,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Celková částka platby v rozpisu plateb se musí rovnat hodnotě Grand / Rounded Total
+apps/erpnext/erpnext/controllers/accounts_controller.py +712,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Celková částka platby v rozpisu plateb se musí rovnat hodnotě Grand / Rounded Total
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Výpis z bankovního účtu zůstatek podle hlavní knihy
 DocType: Job Applicant,Applicant Name,Žadatel Název
 DocType: Authorization Rule,Customer / Item Name,Zákazník / Název zboží
+DocType: Buying Settings,"If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt","Pokud je povoleno, poslední podrobnosti o nákupu položek nebudou získány z předchozí objednávky nebo dokladu o nákupu"
 DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 
 
 The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".
@@ -4816,7 +4824,7 @@
 DocType: Employee Loan,Disbursement Date,výplata Datum
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&quot;Příjemci&quot; nejsou specifikováni
 DocType: BOM Update Tool,Update latest price in all BOMs,Aktualizujte nejnovější cenu všech kusovníků
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +40,Medical Record,Zdravotní záznam
+apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +39,Medical Record,Zdravotní záznam
 DocType: Vehicle,Vehicle,Vozidlo
 DocType: Purchase Invoice,In Words,Slovy
 apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} musí být odesláno
@@ -4835,10 +4843,10 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} transferred from {2} to {3},Množství {0} {1} převedena z {2} na {3}
 DocType: Sales Invoice,Get Advances Received,Získat přijaté zálohy
 DocType: Email Digest,Add/Remove Recipients,Přidat / Odebrat příjemce
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +486,Transaction not allowed against stopped Production Order {0},Transakce není povoleno proti zastavila výrobu Objednat {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +491,Transaction not allowed against stopped Production Order {0},Transakce není povoleno proti zastavila výrobu Objednat {0}
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Chcete-li nastavit tento fiskální rok jako výchozí, klikněte na tlačítko ""Nastavit jako výchozí"""
 apps/erpnext/erpnext/projects/doctype/project/project.py +216,Join,Připojit
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Nedostatek Množství
+apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Nedostatek Množství
 apps/erpnext/erpnext/stock/doctype/item/item.py +645,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,"Vlastnosti Variantu nelze změnit po přemístění zásob. Budete muset vytvořit novou položku, abyste to udělali."
 apps/erpnext/erpnext/stock/doctype/item/item.py +685,Item variant {0} exists with same attributes,Bod varianta {0} existuje s stejné atributy
 DocType: Employee Loan,Repay from Salary,Splatit z platu
@@ -4865,7 +4873,7 @@
 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ě
 DocType: Land Unit,Parent Land Unit,Rodičovská jednotka
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1045,It is needed to fetch Item Details.,"Je třeba, aby přinesla Detaily položky."
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1097,It is needed to fetch Item Details.,"Je třeba, aby přinesla Detaily položky."
 DocType: Fertilizer,Fertilizer Name,Jméno hnojiva
 DocType: Salary Slip,Net Pay,Net Pay
 DocType: Account,Account,Účet
@@ -4885,6 +4893,7 @@
 ,Item Delivery Date,Datum dodání položky
 DocType: Warehouse,PIN,KOLÍK
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +125,Error '{0}' occured. Arguments {1}.,Došlo k chybě {0}. Argumenty {1}.
+DocType: Bin,Reserved Qty for sub contract,Vyhrazené množství pro subdodávky
 DocType: Sales Invoice,Base Change Amount (Company Currency),Základna Změna Částka (Company měna)
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady
 apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Uložte dokument jako první.
@@ -4922,7 +4931,7 @@
 DocType: Salary Detail,Salary Detail,plat Detail
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,"Prosím, nejprve vyberte {0}"
 DocType: Appointment Type,Physician,Lékař
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +833,Batch {0} of Item {1} has expired.,Šarže {0} položky {1} vypršela.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +850,Batch {0} of Item {1} has expired.,Šarže {0} položky {1} vypršela.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Konzultace
 DocType: Sales Invoice,Commission,Provize
 apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Čas list pro výrobu.
@@ -4930,7 +4939,7 @@
 DocType: Physician,Charges,Poplatky
 DocType: Salary Detail,Default Amount,Výchozí částka
 DocType: Lab Test Template,Descriptive,Popisný
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Sklad nebyl nalezen v systému
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95,Warehouse not found in the system,Sklad nebyl nalezen v systému
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Tento měsíc je shrnutí
 DocType: Quality Inspection Reading,Quality Inspection Reading,Kvalita Kontrola Reading
 apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,`Zmrazit zásoby starší než` by mělo být nižší než %d dnů.
@@ -4941,7 +4950,7 @@
 apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratoř
 DocType: Stock Entry Detail,Actual Qty (at source/target),Skutečné množství (u zdroje/cíle)
 DocType: Item Customer Detail,Ref Code,Ref Code
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +71,Customer Group is Required in POS Profile,Zákaznická skupina je vyžadována v POS profilu
+apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Zákaznická skupina je vyžadována v POS profilu
 apps/erpnext/erpnext/config/hr.py +12,Employee records.,Zaměstnanecké záznamy.
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +92,Please set Next Depreciation Date,"Prosím, stojí vedle odpisů Datum"
 DocType: HR Settings,Payroll Settings,Nastavení Mzdové
@@ -5001,7 +5010,7 @@
 apps/erpnext/erpnext/stock/doctype/item/item.py +485,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Položka Změna pořadí již pro tento sklad existuje {1}
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
 apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Trénink Feedback
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +483,Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +488,Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy
 DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kritéria dodavatele skóre karty
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},"Prosím, vyberte Počáteční datum a koncové datum pro položku {0}"
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Samozřejmě je povinné v řadě {0}
@@ -5039,7 +5048,6 @@
 DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLIKÁT PRO DODAVATELE
 DocType: Email Digest,Pending Quotations,Čeká na citace
 apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-of-Sale Profil
-apps/erpnext/erpnext/config/healthcare.py +153,Lab Test Configurations.,Konfigurace laboratorních testů.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Nezajištěných úvěrů
 DocType: Cost Center,Cost Center Name,Jméno nákladového střediska
 DocType: Student,B+,B +
@@ -5081,7 +5089,7 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +203,{0} {1} does not exist,{0} {1} neexistuje
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +321,Please check Multi Currency option to allow accounts with other currency,"Prosím, zkontrolujte více měn možnost povolit účty s jinou měnu"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +85,Item: {0} does not exist in the system,Položka: {0} neexistuje v systému
-apps/erpnext/erpnext/accounts/doctype/account/account.py +108,You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení
+apps/erpnext/erpnext/accounts/doctype/account/account.py +106,You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení
 DocType: Payment Reconciliation,Get Unreconciled Entries,Získat smířit záznamů
 DocType: Payment Reconciliation,From Invoice Date,Z faktury Datum
 DocType: Healthcare Settings,Laboratory Settings,Laboratorní nastavení
@@ -5248,7 +5256,7 @@
 DocType: Employee,Cheque,Šek
 DocType: Training Event,Employee Emails,E-maily zaměstnanců
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,Řada Aktualizováno
-apps/erpnext/erpnext/accounts/doctype/account/account.py +161,Report Type is mandatory,Report Type je povinné
+apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Report Type is mandatory,Report Type je povinné
 DocType: Item,Serial Number Series,Sériové číslo Series
 apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný pro skladovou položku {0} na řádku {1}
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Maloobchod a velkoobchod
@@ -5260,7 +5268,6 @@
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Úspěšně smířeni
 DocType: Request for Quotation Supplier,Download PDF,Stáhnout PDF
 DocType: Production Order,Planned End Date,Plánované datum ukončení
-apps/erpnext/erpnext/controllers/buying_controller.py +424,Please enter Schedule Date,Zadejte prosím datum rozvrhu
 apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informace o typu dárce.
 DocType: Request for Quotation,Supplier Detail,dodavatel Detail
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Chyba ve vzorci nebo stavu: {0}
@@ -5272,7 +5279,7 @@
 DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Pokud není zatrženo, seznam bude muset být přidány ke každé oddělení, kde má být použit."
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +103,Creating {0},Vytváření {0}
 apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Zdrojové a cílové skladů nemohou být stejné
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +561,Posting date and posting time is mandatory,Datum a čas zadání je povinný
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +566,Posting date and posting time is mandatory,Datum a čas zadání je povinný
 apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Daňové šablona pro nákup transakcí.
 ,Item Prices,Ceny Položek
 DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,"Ve slovech budou viditelné, jakmile uložíte objednávce."
@@ -5286,9 +5293,9 @@
 DocType: Purchase Invoice,Advance Payments,Zálohové platby
 DocType: Purchase Taxes and Charges,On Net Total,On Net Celkem
 apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Hodnota atributu {0} musí být v rozmezí od {1} až {2} v krocích po {3} pro item {4}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +166,Target warehouse in row {0} must be same as Production Order,Target sklad v řádku {0} musí být stejná jako výrobní zakázky
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171,Target warehouse in row {0} must be same as Production Order,Target sklad v řádku {0} musí být stejná jako výrobní zakázky
 DocType: Restaurant Reservation,Waitlisted,Vyčkejte
-apps/erpnext/erpnext/accounts/doctype/account/account.py +126,Currency can not be changed after making entries using some other currency,Měna nemůže být změněn po provedení položky pomocí jiné měně
+apps/erpnext/erpnext/accounts/doctype/account/account.py +124,Currency can not be changed after making entries using some other currency,Měna nemůže být změněn po provedení položky pomocí jiné měně
 DocType: Shipping Rule,Fixed,Pevný
 DocType: Vehicle Service,Clutch Plate,Kotouč spojky
 DocType: Company,Round Off Account,Zaokrouhlovací účet
@@ -5344,6 +5351,7 @@
 apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Neuplynula
 DocType: Student Log,Achievement,Úspěch
 DocType: Batch,Source Document Type,Zdrojový typ dokumentu
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosím, nastavte systém pro pojmenování zaměstnanců v oblasti lidských zdrojů&gt; Nastavení HR"
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Byly vytvořeny následující kurzy
 DocType: Journal Entry,Total Debit,Celkem Debit
 DocType: Manufacturing Settings,Default Finished Goods Warehouse,Výchozí sklad hotových výrobků
@@ -5379,6 +5387,7 @@
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,To je založeno na transakcích proti tomuto zákazníkovi. Viz časovou osu níže podrobnosti
 DocType: Company,Credit Days Based On,Úvěrové Dny Based On
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Řádek {0}: Přidělená částka {1} musí být menší než nebo se rovná částce zaplacení výstavního {2}
+DocType: Program Enrollment Tool,New Academic Term,Nový akademický termín
 ,Course wise Assessment Report,Průběžná hodnotící zpráva
 DocType: Tax Rule,Tax Rule,Daňové Pravidlo
 DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu
@@ -5399,7 +5408,7 @@
 DocType: Attendance,Employee Name,Jméno zaměstnance
 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 +98,Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
+apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} byl změněn. Prosím aktualizujte.
 DocType: Leave Block List,Stop users from making Leave Applications on following days.,Přestaňte uživatelům provádět Nechat aplikací v následujících dnech.
 DocType: Asset Maintenance Team,Maintenance Team Members,Členové týmu údržby
@@ -5419,6 +5428,7 @@
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID projektu
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +532,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},"Řádek č {0}: Částka nemůže být větší než Čekající Částka proti Expense nároku {1}. Do doby, než množství je {2}"
 DocType: Assessment Plan,Schedule,Plán
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Skupina zákazníků&gt; Území
 DocType: Account,Parent Account,Nadřazený účet
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,K dispozici
 DocType: Quality Inspection Reading,Reading 3,Čtení 3
@@ -5449,7 +5459,7 @@
 DocType: Maintenance Team Member,Maintenance Team Member,Člen týmu údržby
 DocType: Agriculture Analysis Criteria,Soil Analysis,Analýza půd
 apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kód předmětu:
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,"Prosím, zadejte výdajového účtu"
+apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,"Prosím, zadejte výdajového účtu"
 DocType: Account,Stock,Sklad
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Řádek # {0}: Reference Document Type musí být jedním z objednávky, faktury nebo Journal Entry"
 DocType: Employee,Current Address,Aktuální adresa
@@ -5468,7 +5478,7 @@
 DocType: GL Entry,Transaction Date,Transakce Datum
 DocType: Production Plan Item,Planned Qty,Plánované Množství
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total Tax
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +182,For Quantity (Manufactured Qty) is mandatory,Pro Množství (Vyrobeno ks) je povinné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +187,For Quantity (Manufactured Qty) is mandatory,Pro Množství (Vyrobeno ks) je povinné
 DocType: Stock Entry,Default Target Warehouse,Výchozí cílový sklad
 DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Company Měna)
 apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Rok Datum ukončení nesmí být starší než datum Rok Start. Opravte data a zkuste to znovu.
@@ -5501,10 +5511,9 @@
 apps/erpnext/erpnext/stock/get_item_details.py +142,"Item {0} is a template, please select one of its variants","Položka {0} je šablona, prosím vyberte jednu z jeho variant"
 DocType: Asset,Asset Category,Asset Kategorie
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Net plat nemůže být záporný
-DocType: Assessment Plan,Room,Pokoj
 DocType: Purchase Order,Advance Paid,Vyplacené zálohy
 DocType: Item,Item Tax,Daň Položky
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +868,Material to Supplier,Materiál Dodavateli
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +872,Material to Supplier,Materiál Dodavateli
 DocType: Soil Texture,Loamy Sand,Loamy Sand
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +594,Excise Invoice,Spotřební Faktura
 apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Práh {0}% objeví více než jednou
@@ -5517,7 +5526,7 @@
 DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Zvažte daň či poplatek za
 DocType: Driver,Driving License Category,Kategorie řidičských oprávnění
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Skutečné Množství je povinné
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} v současné době disponuje {1} hodnotící tabulkou dodavatelů a objednávky na nákup tohoto dodavatele by měly být vydány s opatrností.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +82,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} v současné době disponuje {1} hodnotící tabulkou dodavatelů a objednávky na nákup tohoto dodavatele by měly být vydány s opatrností.
 DocType: Asset Maintenance Team,Asset Maintenance Team,Tým pro údržbu aktiv
 DocType: Employee Loan,Loan Type,Typ úvěru
 DocType: Scheduling Tool,Scheduling Tool,Plánování Tool
@@ -5549,7 +5558,7 @@
 DocType: Production Order,Actual Operating Cost,Skutečné provozní náklady
 DocType: Payment Entry,Cheque/Reference No,Šek / Referenční číslo
 DocType: Soil Texture,Clay Loam,Clay Loam
-apps/erpnext/erpnext/accounts/doctype/account/account.py +83,Root cannot be edited.,Root nelze upravovat.
+apps/erpnext/erpnext/accounts/doctype/account/account.py +81,Root cannot be edited.,Root nelze upravovat.
 DocType: Item,Units of Measure,Jednotky měření
 DocType: Manufacturing Settings,Allow Production on Holidays,Povolit Výrobu při dovolené
 DocType: Sales Order,Customer's Purchase Order Date,Zákazníka Objednávka Datum
@@ -5561,16 +5570,17 @@
 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 +84,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Daňová kategorie byla změněna na &quot;Celkem&quot;, protože všechny položky jsou položky, které nejsou skladem"
+apps/erpnext/erpnext/controllers/buying_controller.py +87,"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/upload_attendance/upload_attendance.py +103,Please select a csv file,Vyberte soubor csv
 DocType: Student Leave Application,Mark as Present,Označit jako dárek
 DocType: Supplier Scorecard,Indicator Color,Barva indikátoru
 DocType: Purchase Order,To Receive and Bill,Přijímat a Bill
+apps/erpnext/erpnext/controllers/buying_controller.py +455,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/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Návrhář
 apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Podmínky Template
 DocType: Serial No,Delivery Details,Zasílání
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +491,Cost Center is required in row {0} in Taxes table for type {1},Nákladové středisko je nutné v řadě {0} na daních tabulka typu {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495,Cost Center is required in row {0} in Taxes table for type {1},Nákladové středisko je nutné v řadě {0} na daních tabulka typu {1}
 DocType: Program,Program Code,Kód programu
 DocType: Terms and Conditions,Terms and Conditions Help,Podmínky nápovědy
 ,Item-wise Purchase Register,Item-wise registr nákupu
@@ -5588,7 +5598,7 @@
 DocType: Leave Type,Is Carry Forward,Je převádět
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,Get Items from BOM,Položka získaná z BOM
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Dodací lhůta dny
-apps/erpnext/erpnext/controllers/accounts_controller.py +600,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Řádek # {0}: Vysílání datum musí být stejné jako datum nákupu {1} aktiva {2}
+apps/erpnext/erpnext/controllers/accounts_controller.py +611,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
@@ -5604,7 +5614,7 @@
 DocType: GL Entry,Is Opening,Se otevírá
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +194,Row {0}: Debit entry can not be linked with a {1},Row {0}: záporný nemůže být spojována s {1}
 DocType: Journal Entry,Subscription Section,Sekce odběru
-apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Account {0} does not exist,Účet {0} neexistuje
+apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account {0} does not exist,Účet {0} neexistuje
 DocType: Training Event,Training Program,Tréninkový program
 DocType: Account,Cash,V hotovosti
 DocType: Employee,Short biography for website and other publications.,Krátký životopis na internetové stránky a dalších publikací.
