diff --git a/erpnext/translations/sk.csv b/erpnext/translations/sk.csv
index e693628..7235863 100644
--- a/erpnext/translations/sk.csv
+++ b/erpnext/translations/sk.csv
@@ -47,11 +47,11 @@
 DocType: Quality Inspection Reading,Parameter,Parametr
 apps/erpnext/erpnext/projects/doctype/project/project.py +43,Expected End Date can not be less than Expected Start Date,"Očakávané Dátum ukončenia nemôže byť nižšia, než sa očakávalo dáta začatia"
 apps/erpnext/erpnext/utilities/transaction_base.py +107,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Riadok # {0}: Cena musí byť rovnaké, ako {1}: {2} ({3} / {4})"
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +204,New Leave Application,New Leave Application
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +206,New Leave Application,New Leave Application
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +134,Bank Draft,Bank Návrh
 DocType: Features Setup,1. To maintain the customer wise item code and to make them searchable based on their code use this option,"1.Chcete-li zachovat zákazníkovo produktové číslo a také podle něj vyhledávat, použijte tuto možnost"
 DocType: Mode of Payment Account,Mode of Payment Account,Způsob platby účtu
-apps/erpnext/erpnext/stock/doctype/item/item.js +34,Show Variants,Zobraziť Varianty
+apps/erpnext/erpnext/stock/doctype/item/item.js +49,Show Variants,Zobraziť Varianty
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +478,Quantity,Množství
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +174,Loans (Liabilities),Úvěry (závazky)
 DocType: Employee Education,Year of Passing,Rok Passing
@@ -76,7 +76,7 @@
 DocType: Production Order Operation,Work In Progress,Work in Progress
 DocType: Employee,Holiday List,Dovolená Seznam
 DocType: Time Log,Time Log,Time Log
-apps/erpnext/erpnext/public/js/setup_wizard.js +289,Accountant,Účetní
+apps/erpnext/erpnext/public/js/setup_wizard.js +292,Accountant,Účetní
 DocType: Cost Center,Stock User,Sklad Užívateľ
 DocType: Company,Phone No,Telefon
 DocType: Time Log,"Log of Activities performed by users against Tasks that can be used for tracking time, billing.","Log činností vykonávaných uživateli proti úkoly, které mohou být použity pro sledování času, fakturaci."
@@ -91,7 +91,7 @@
 DocType: Bin,Quantity Requested for Purchase,Požadovaného množství na nákup
 DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Pripojiť CSV súbor s dvomi stĺpci, jeden pre starý názov a jeden pre nový názov"
 DocType: Packed Item,Parent Detail docname,Parent Detail docname
-apps/erpnext/erpnext/public/js/setup_wizard.js +377,Kg,Kg
+apps/erpnext/erpnext/public/js/setup_wizard.js +380,Kg,Kg
 apps/erpnext/erpnext/config/hr.py +48,Opening for a Job.,Otevření o zaměstnání.
 DocType: Item Attribute,Increment,Prírastok
 apps/erpnext/erpnext/public/js/stock_analytics.js +63,Select Warehouse...,Vyberte Warehouse ...
@@ -99,7 +99,7 @@
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Rovnaký Spoločnosť je zapísaná viac ako raz
 DocType: Employee,Married,Ženatý
 apps/erpnext/erpnext/accounts/party.py +38,Not permitted for {0},Nie je dovolené {0}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +391,Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +392,Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
 DocType: Payment Reconciliation,Reconcile,Srovnat
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,Potraviny
 DocType: Quality Inspection Reading,Reading 1,Čtení 1
@@ -146,7 +146,7 @@
 DocType: Employee,Mr,Pan
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +33,Supplier Type / Supplier,Dodavatel Typ / dovozce
 DocType: Naming Series,Prefix,Prefix
-apps/erpnext/erpnext/public/js/setup_wizard.js +374,Consumable,Spotřební
+apps/erpnext/erpnext/public/js/setup_wizard.js +377,Consumable,Spotřební
 DocType: Upload Attendance,Import Log,Záznam importu
 apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.js +19,Send,Odeslat
 DocType: Sales Invoice Item,Delivered By Supplier,Dodáva sa podľa dodávateľa
@@ -165,7 +165,7 @@
 DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
 All dates and employee combination in the selected period will come in the template, with existing attendance records","Stáhněte si šablony, vyplňte potřebné údaje a přiložte upravený soubor.
  Všechny termíny a zaměstnanec kombinaci ve zvoleném období přijde v šabloně, se stávajícími evidence docházky"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +446,Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +444,Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
 DocType: Time Log Batch,Will be updated after Sales Invoice is Submitted.,Bude aktualizováno po odeslání faktury.
 apps/erpnext/erpnext/controllers/accounts_controller.py +511,"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 +90,Settings for HR Module,Nastavenie modulu HR
@@ -223,17 +223,17 @@
 DocType: Production Plan Item,SO Pending Qty,SO Pending Množství
 DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Vytvoří výplatní pásku na výše uvedených kritérií.
 apps/erpnext/erpnext/config/buying.py +18,Request for purchase.,Žádost o koupi.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +171,Only the selected Leave Approver can submit this Leave Application,Pouze vybraný Leave schvalovač může podat této dovolené aplikaci
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +173,Only the selected Leave Approver can submit this Leave Application,Pouze vybraný Leave schvalovač může podat této dovolené aplikaci
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +114,Relieving Date must be greater than Date of Joining,Uvolnění Datum musí být větší než Datum spojování
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +172,Leaves per Year,Listy za rok
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +187,Please set Naming Series for {0} via Setup > Settings > Naming Series,Prosím nastavte Pomenovanie Series pre {0} cez Nastavenia&gt; Nastavenia&gt; Naming Séria
 DocType: Time Log,Will be updated when batched.,Bude aktualizována při dávkově.
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +104,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Zkontrolujte ""Je Advance"" proti účtu {1}, pokud je to záloha záznam."
-apps/erpnext/erpnext/stock/utils.py +174,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
+apps/erpnext/erpnext/stock/utils.py +178,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
 DocType: Item Website Specification,Item Website Specification,Položka webových stránek Specifikace
 DocType: Payment Tool,Reference No,Referenční číslo
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +392,Leave Blocked,Nechte Blokováno
-apps/erpnext/erpnext/stock/doctype/item/item.py +546,Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti na {1}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +398,Leave Blocked,Nechte Blokováno
+apps/erpnext/erpnext/stock/doctype/item/item.py +576,Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti na {1}
 apps/erpnext/erpnext/accounts/utils.py +341,Annual,Roční
 DocType: Stock Reconciliation Item,Stock Reconciliation Item,Reklamní Odsouhlasení Item
 DocType: Stock Entry,Sales Invoice No,Prodejní faktuře č
@@ -245,11 +245,11 @@
 DocType: Pricing Rule,Supplier Type,Dodavatel Type
 DocType: Item,Publish in Hub,Publikovat v Hub
 ,Terretory,Terretory
-apps/erpnext/erpnext/stock/doctype/item/item.py +566,Item {0} is cancelled,Položka {0} je zrušená
+apps/erpnext/erpnext/stock/doctype/item/item.py +596,Item {0} is cancelled,Položka {0} je zrušená
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +607,Material Request,Požadavek na materiál
 DocType: Bank Reconciliation,Update Clearance Date,Aktualizace Výprodej Datum
 DocType: Item,Purchase Details,Nákup Podrobnosti
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +323,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebol nájdený v &quot;suroviny dodanej&quot; tabuľky v objednávke {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +321,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebol nájdený v &quot;suroviny dodanej&quot; tabuľky v objednávke {1}
 DocType: Employee,Relation,Vztah
 DocType: Shipping Rule,Worldwide Shipping,Celosvetovo doprava
 apps/erpnext/erpnext/config/selling.py +23,Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
@@ -270,8 +270,7 @@
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Nejnovější
 apps/erpnext/erpnext/public/js/setup_wizard.js +143,Max 5 characters,Max 5 znaků
 DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,První Leave schvalovač v seznamu bude nastaven jako výchozí Leave schvalujícího
-DocType: Manufacturing Settings,"Disables creation of time logs against Production Orders.
-Operations shall not be tracked against Production Order",Zakáže vytváranie časových protokolov proti výrobnej zákazky. Transakcie nesmú byť sledovaná proti výrobnej zákazky
+apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Náklady na činnosť na jedného zamestnanca
 DocType: Accounts Settings,Settings for Accounts,Nastavenie Účtovníctva
 apps/erpnext/erpnext/config/crm.py +90,Manage Sales Person Tree.,Správa obchodník strom.
 DocType: Item,Synced With Hub,Synchronizovány Hub
@@ -292,7 +291,7 @@
 DocType: Sales Invoice Item,Delivery Note,Dodací list
 apps/erpnext/erpnext/config/learn.py +72,Setting up Taxes,Nastavenie Dane
 apps/erpnext/erpnext/accounts/utils.py +191,Payment Entry has been modified after you pulled it. Please pull it again.,"Vstup Platba byla změněna poté, co ji vytáhl. Prosím, vytáhněte ji znovu."
-apps/erpnext/erpnext/stock/doctype/item/item.py +347,{0} entered twice in Item Tax,{0} vložené dvakrát v Daňovej Položke
+apps/erpnext/erpnext/stock/doctype/item/item.py +377,{0} entered twice in Item Tax,{0} vložené dvakrát v Daňovej Položke
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +105,Summary for this week and pending activities,Zhrnutie pre tento týždeň a prebiehajúcim činnostiam
 DocType: Workstation,Rent Cost,Rent Cost
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +74,Please select month and year,Vyberte měsíc a rok
@@ -301,13 +300,14 @@
 DocType: GL Entry,Debit Amount in Account Currency,Debetné Čiastka v mene účtu
 DocType: Shipping Rule,Valid for Countries,"Platí pre krajiny,"
 DocType: Features Setup,"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Všech souvisejících oblastech, jako je dovozní měně, přepočítací koeficient, dovoz celkem, dovoz celkovém součtu etc jsou k dispozici v dokladu o koupi, dodavatelů nabídky, faktury, objednávky apod"
-apps/erpnext/erpnext/stock/doctype/item/item.js +33,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Tento bod je šablona a nemůže být použit v transakcích. Atributy položky budou zkopírovány do variant, pokud je nastaveno ""No Copy"""
+apps/erpnext/erpnext/stock/doctype/item/item.js +48,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Tento bod je šablona a nemůže být použit v transakcích. Atributy položky budou zkopírovány do variant, pokud je nastaveno ""No Copy"""
 apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +69,Total Order Considered,Celková objednávka Zvážil
 apps/erpnext/erpnext/config/hr.py +110,"Employee designation (e.g. CEO, Director etc.).","Označení zaměstnanců (např CEO, ředitel atd.)."
 apps/erpnext/erpnext/controllers/recurring_document.py +196,Please enter 'Repeat on Day of Month' field value,"Prosím, zadejte ""Opakujte dne měsíce"" hodnoty pole"
 DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,"Sazba, za kterou je zákazník měny převeden na zákazníka základní měny"
 DocType: Features Setup,"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","K dispozici v BOM, dodací list, fakturu, výrobní zakázky, objednávky, doklad o koupi, prodejní faktury odběratele, Stock vstupu, časový rozvrh"
 DocType: Item Tax,Tax Rate,Sadzba dane
+apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +54,{0} already allocated for Employee {1} for period {2} to {3},{0} už pridelené pre zamestnancov {1} na dobu {2} až {3}
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +628,Select Item,Select Položka
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Item: {0} managed batch-wise, can not be reconciled using \
 					Stock Reconciliation, instead use Stock Entry","Item: {0} podařilo dávkové, nemůže být v souladu s použitím \
@@ -321,7 +321,7 @@
 DocType: GL Entry,Debit Amount,Debetné Suma
 apps/erpnext/erpnext/accounts/party.py +223,There can only be 1 Account per Company in {0} {1},Tam môže byť len 1 účet na spoločnosti v {0} {1}
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Your email address,Vaše e-mailová adresa
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +208,Please see attachment,"Prosím, viz příloha"
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +215,Please see attachment,"Prosím, viz příloha"
 DocType: Purchase Order,% Received,% Prijaté
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +18,Setup Already Complete!!,Setup již dokončen !!
 ,Finished Goods,Hotové zboží
@@ -348,7 +348,7 @@
 ,Purchase Register,Nákup Register
 DocType: Landed Cost Item,Applicable Charges,Použitelné Poplatky
 DocType: Workstation,Consumable Cost,Spotřební Cost
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +167,{0} ({1}) must have role 'Leave Approver',"{0} ({1}), musí mať úlohu ""Schvalovateľ voľna"""
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +169,{0} ({1}) must have role 'Leave Approver',"{0} ({1}), musí mať úlohu ""Schvalovateľ voľna"""
 DocType: Purchase Receipt,Vehicle Date,Dátum Vehicle
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +39,Medical,Lékařský
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +143,Reason for losing,Důvod ztráty
@@ -382,7 +382,7 @@
 apps/erpnext/erpnext/config/manufacturing.py +74,Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.
 DocType: Accounts Settings,Accounts Frozen Upto,Účty Frozen aľ
 DocType: SMS Log,Sent On,Poslán na
-apps/erpnext/erpnext/stock/doctype/item/item.py +523,Attribute {0} selected multiple times in Attributes Table,Atribút {0} vybraný niekoľkokrát v atribútoch tabuľke
+apps/erpnext/erpnext/stock/doctype/item/item.py +553,Attribute {0} selected multiple times in Attributes Table,Atribút {0} vybraný niekoľkokrát v atribútoch tabuľke
 DocType: HR Settings,Employee record is created using selected field. ,Záznam Zaměstnanec je vytvořena pomocí vybrané pole.
 DocType: Sales Order,Not Applicable,Nehodí se
 apps/erpnext/erpnext/config/hr.py +140,Holiday master.,Holiday master.
@@ -410,7 +410,7 @@
 apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +24,Add Subscribers,Pridať predplatitelia
 apps/erpnext/erpnext/public/js/feature_setup.js +220,""" does not exists",""" Neexistuje"
 DocType: Pricing Rule,Valid Upto,Valid aľ
-apps/erpnext/erpnext/public/js/setup_wizard.js +319,List a few of your customers. They could be organizations or individuals.,"Vypíšte zopár svojich zákazníkov. Môžu to byť organizácie, ale aj jednotlivci."
+apps/erpnext/erpnext/public/js/setup_wizard.js +322,List a few of your customers. They could be organizations or individuals.,"Vypíšte zopár svojich zákazníkov. Môžu to byť organizácie, ale aj jednotlivci."
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Direct Income,Přímý příjmů
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +33,"Can not filter based on Account, if grouped by Account","Nelze filtrovat na základě účtu, pokud seskupeny podle účtu"
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Administrative Officer,Správní ředitel
@@ -421,7 +421,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +305,Please enter Warehouse for which Material Request will be raised,"Prosím, zadejte sklad, který bude materiál žádosti předložené"
 DocType: Production Order,Additional Operating Cost,Další provozní náklady
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,Kosmetika
-apps/erpnext/erpnext/stock/doctype/item/item.py +428,"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky"
+apps/erpnext/erpnext/stock/doctype/item/item.py +458,"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky"
 DocType: Shipping Rule,Net Weight,Hmotnost
 DocType: Employee,Emergency Phone,Nouzový telefon
 ,Serial No Warranty Expiry,Pořadové č záruční lhůty
@@ -489,7 +489,7 @@
 DocType: Quotation,Quotation To,Ponuka k
 DocType: Lead,Middle Income,Středními příjmy
 apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +58,Opening (Cr),Otvor (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +672,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Východzí merná jednotka bodu {0} nemôže byť zmenená priamo, pretože ste už nejaké transakcie (y) s iným nerozpustených. Budete musieť vytvoriť novú položku použiť iný predvolený UOM."
+apps/erpnext/erpnext/stock/doctype/item/item.py +702,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Východzí merná jednotka bodu {0} nemôže byť zmenená priamo, pretože ste už nejaké transakcie (y) s iným nerozpustených. Budete musieť vytvoriť novú položku použiť iný predvolený UOM."
 apps/erpnext/erpnext/accounts/utils.py +195,Allocated amount can not be negative,Přidělená částka nemůže být záporná
 DocType: Purchase Order Item,Billed Amt,Účtovaného Amt
 DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny."
@@ -526,7 +526,7 @@
 DocType: Sales Person,Sales Person Targets,Obchodník cíle
 DocType: Production Order Operation,In minutes,V minutách
 DocType: Issue,Resolution Date,Rozlišení Datum
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +637,Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +644,Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0}
 DocType: Selling Settings,Customer Naming By,Zákazník Pojmenování By
 apps/erpnext/erpnext/accounts/doctype/account/account.js +67,Convert to Group,Převést do skupiny
 DocType: Activity Cost,Activity Type,Druh činnosti
@@ -565,7 +565,7 @@
 DocType: Hub Settings,Seller City,Prodejce City
 DocType: Email Digest,Next email will be sent on:,Další e-mail bude odeslán dne:
 DocType: Offer Letter Term,Offer Letter Term,Ponuka Letter Term
-apps/erpnext/erpnext/stock/doctype/item/item.py +503,Item has variants.,Položka má varianty.
+apps/erpnext/erpnext/stock/doctype/item/item.py +533,Item has variants.,Položka má varianty.
 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/buying/page/purchase_analytics/purchase_analytics.js +88,Tree Type,Tree Type
@@ -599,7 +599,7 @@
 DocType: Opportunity,Opportunity From,Příležitost Z
 apps/erpnext/erpnext/config/hr.py +33,Monthly salary statement.,Měsíční plat prohlášení.
 DocType: Item Group,Website Specifications,Webových stránek Specifikace
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +205,New Account,Nový účet
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +208,New Account,Nový účet
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +21,{0}: From {0} of type {1},{0}: Od {0} typu {1}
 apps/erpnext/erpnext/controllers/buying_controller.py +274,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
 apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +27,Accounting Entries can be made against leaf nodes. Entries against Groups are not allowed.,Účtovné Prihlášky možno proti koncovej uzly. Záznamy proti skupinám nie sú povolené.
@@ -663,15 +663,15 @@
 apps/erpnext/erpnext/stock/get_item_details.py +262,Price List not selected,Ceník není zvolen
 DocType: Employee,Family Background,Rodinné poměry
 DocType: Process Payroll,Send Email,Odeslat email
-apps/erpnext/erpnext/stock/doctype/item/item.py +108,Warning: Invalid Attachment {0},Varovanie: Neplatná Príloha {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +138,Warning: Invalid Attachment {0},Varovanie: Neplatná Príloha {0}
 apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +88,No Permission,Nemáte oprávnění
 DocType: Company,Default Bank Account,Výchozí Bankovní účet
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +47,"To filter based on Party, select Party Type first","Ak chcete filtrovať na základe Party, vyberte typ Party prvý"
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"""Aktualizovať Sklad ' nie je možné skontrolovať, pretože položky nie sú dodané cez {0}"
-apps/erpnext/erpnext/public/js/setup_wizard.js +377,Nos,Nos
+apps/erpnext/erpnext/public/js/setup_wizard.js +380,Nos,Nos
 DocType: Item,Items with higher weightage will be shown higher,Položky s vyšším weightage budú zobrazené vyššie
 DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Odsouhlasení Detail
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +629,My Invoices,Moje Faktúry
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +636,My Invoices,Moje Faktúry
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +43,No employee found,Žádný zaměstnanec nalezeno
 DocType: Purchase Order,Stopped,Zastaveno
 DocType: Item,If subcontracted to a vendor,Ak sa subdodávky na dodávateľa
@@ -706,7 +706,7 @@
 DocType: Sales Order Item,Projected Qty,Předpokládané množství
 DocType: Sales Invoice,Payment Due Date,Splatno dne
 DocType: Newsletter,Newsletter Manager,Newsletter Manažér
-apps/erpnext/erpnext/stock/doctype/item/item.js +231,Item Variant {0} already exists with same attributes,Variant Položky {0} už existuje s rovnakými vlastnosťami
+apps/erpnext/erpnext/stock/doctype/item/item.js +246,Item Variant {0} already exists with same attributes,Variant Položky {0} už existuje s rovnakými vlastnosťami
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +95,'Opening',"""Otváranie"""
 DocType: Notification Control,Delivery Note Message,Delivery Note Message
 DocType: Expense Claim,Expenses,Výdaje
@@ -767,7 +767,7 @@
 DocType: Supplier,Default Payable Accounts,Výchozí úplatu účty
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +40,Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje
 DocType: Features Setup,Item Barcode,Položka Barcode
-apps/erpnext/erpnext/stock/doctype/item/item.py +498,Item Variants {0} updated,Varianty Položky {0} aktualizované
+apps/erpnext/erpnext/stock/doctype/item/item.py +528,Item Variants {0} updated,Varianty Položky {0} aktualizované
 DocType: Quality Inspection Reading,Reading 6,Čtení 6
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Záloha přijaté faktury
 DocType: Address,Shop,Obchod
@@ -777,7 +777,7 @@
 DocType: Employee,Permanent Address Is,Trvalé bydliště je
 DocType: Production Order Operation,Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?
 apps/erpnext/erpnext/public/js/setup_wizard.js +252,The Brand,Značka
-apps/erpnext/erpnext/controllers/status_updater.py +163,Allowance for over-{0} crossed for Item {1}.,Příspěvek na nadměrné {0} přešel k bodu {1}.
+apps/erpnext/erpnext/controllers/status_updater.py +164,Allowance for over-{0} crossed for Item {1}.,Příspěvek na nadměrné {0} přešel k bodu {1}.
 DocType: Employee,Exit Interview Details,Exit Rozhovor Podrobnosti
 DocType: Item,Is Purchase Item,je Nákupní Položka
 DocType: Journal Entry Account,Purchase Invoice,Přijatá faktura
@@ -805,7 +805,7 @@
 DocType: Pricing Rule,Max Qty,Max Množství
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +106,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Platba na prodejní / nákupní objednávce by měly být vždy označeny jako předem
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +16,Chemical,Chemický
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +693,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 +691,All items have already been transferred for this Production Order.,Všechny položky již byly převedeny na výrobu tohoto řádu.
 DocType: Process Payroll,Select Payroll Year and Month,Vyberte Payroll rok a mesiac
 apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +32,"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account (by clicking on Add Child) of type ""Bank""",Prejdite na príslušnej skupiny (zvyčajne využitia finančných prostriedkov&gt; obežných aktív&gt; bankových účtov a vytvoriť nový účet (kliknutím na Pridať dieťa) typu &quot;Bank&quot;
 DocType: Workstation,Electricity Cost,Cena elektřiny
@@ -841,7 +841,7 @@
 DocType: POS Profile,Cash/Bank Account,Hotovostní / Bankovní účet
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +70,Removed items with no change in quantity or value.,Odstránené položky bez zmeny množstva alebo hodnoty.
 DocType: Delivery Note,Delivery To,Doručení do
-apps/erpnext/erpnext/stock/doctype/item/item.py +520,Attribute table is mandatory,Atribút tabuľka je povinné
+apps/erpnext/erpnext/stock/doctype/item/item.py +550,Attribute table is mandatory,Atribút tabuľka je povinné
 DocType: Production Planning Tool,Get Sales Orders,Získat Prodejní objednávky
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +64,{0} can not be negative,{0} nemôže byť záporné
 apps/erpnext/erpnext/templates/form_grid/item_grid.html +72,Discount,Sleva
@@ -890,7 +890,7 @@
 DocType: Time Log Batch,updated via Time Logs,aktualizovať cez čas Záznamy
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Průměrný věk
 DocType: Opportunity,Your sales person who will contact the customer in future,"Váš obchodní zástupce, který bude kontaktovat zákazníka v budoucnu"
-apps/erpnext/erpnext/public/js/setup_wizard.js +341,List a few of your suppliers. They could be organizations or individuals.,"Napíšte niekoľkých svojich dodávateľov. Môžu to byť organizácie, ale aj jednotlivci."
+apps/erpnext/erpnext/public/js/setup_wizard.js +344,List a few of your suppliers. They could be organizations or individuals.,"Napíšte niekoľkých svojich dodávateľov. Môžu to byť organizácie, ale aj jednotlivci."
 DocType: Company,Default Currency,Predvolená mena
 DocType: Contact,Enter designation of this Contact,Zadejte označení této Kontakt
 DocType: Expense Claim,From Employee,Od Zaměstnance
@@ -925,7 +925,7 @@
 ,Trial Balance for Party,Trial váhy pre stranu
 DocType: Lead,Consultant,Konzultant
 DocType: Salary Slip,Earnings,Výdělek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Finished Item {0} must be entered for Manufacture type entry,Dokončené Položka {0} musí byť zadaný pre vstup typu Výroba
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +355,Finished Item {0} must be entered for Manufacture type entry,Dokončené Položka {0} musí byť zadaný pre vstup typu Výroba
 apps/erpnext/erpnext/config/learn.py +77,Opening Accounting Balance,Otvorenie účtovníctva Balance
 DocType: Sales Invoice Advance,Sales Invoice Advance,Prodejní faktury Advance
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +398,Nothing to request,Nic požadovat
@@ -939,8 +939,9 @@
 DocType: Purchase Invoice,Is Return,Je Return
 DocType: Price List Country,Price List Country,Cenník Krajina
 apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +123,Further nodes can be only created under 'Group' type nodes,"Další uzly mohou být pouze vytvořena v uzlech typu ""skupiny"""
+apps/erpnext/erpnext/utilities/doctype/contact/contact.py +67,Please set Email ID,Prosím nastavte e-mail ID
 DocType: Item,UOMs,Merné Jednotky
-apps/erpnext/erpnext/stock/utils.py +167,{0} valid serial nos for Item {1},{0} platné sériové čísla pre položky {1}
+apps/erpnext/erpnext/stock/utils.py +171,{0} valid serial nos for Item {1},{0} platné sériové čísla pre položky {1}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Kód položky nemůže být změněn pro Serial No.
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +22,POS Profile {0} already created for user: {1} and company {2},POS Profile {0} už vytvorili pre užívateľov: {1} a spoločnosť {2}
 DocType: Purchase Order Item,UOM Conversion Factor,Faktor konverzie MJ
@@ -949,7 +950,7 @@
 DocType: Account,Balance Sheet,Rozvaha
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +561,Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
 DocType: Opportunity,Your sales person will get a reminder on this date to contact the customer,"Váš obchodní zástupce dostane upomínku na tento den, aby kontaktoval zákazníka"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +210,"Further accounts can be made under Groups, but entries can be made against non-Groups","Ďalšie účty môžu byť vyrobené v rámci skupiny, ale údaje je možné proti non-skupín"
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +213,"Further accounts can be made under Groups, but entries can be made against non-Groups","Ďalšie účty môžu byť vyrobené v rámci skupiny, ale údaje je možné proti non-skupín"
 apps/erpnext/erpnext/config/hr.py +125,Tax and other salary deductions.,Daňové a jiné platové srážky.
 DocType: Lead,Lead,Obchodná iniciatíva
 DocType: Email Digest,Payables,Závazky
@@ -979,7 +980,7 @@
 DocType: Contact,User ID,User ID
 apps/erpnext/erpnext/accounts/doctype/account/account.js +57,View Ledger,View Ledger
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Nejstarší
-apps/erpnext/erpnext/stock/doctype/item/item.py +405,"An Item Group exists with same name, please change the item name or rename the item group","Položka Group existuje se stejným názvem, prosím, změnit název položky nebo přejmenovat skupinu položek"
+apps/erpnext/erpnext/stock/doctype/item/item.py +435,"An Item Group exists with same name, please change the item name or rename the item group","Položka Group existuje se stejným názvem, prosím, změnit název položky nebo přejmenovat skupinu položek"
 DocType: Production Order,Manufacture against Sales Order,Výroba na odběratele
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +429,Rest Of The World,Zbytek světa
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Položka {0} nemůže mít dávku
@@ -1024,12 +1025,13 @@
 DocType: Employee,Place of Issue,Místo vydání
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +59,Contract,Smlouva
 DocType: Email Digest,Add Quote,Pridať ponuku
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +490,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 +488,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 +83,Indirect Expenses,Nepřímé náklady
 apps/erpnext/erpnext/controllers/selling_controller.py +163,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Zemědělství
-apps/erpnext/erpnext/public/js/setup_wizard.js +362,Your Products or Services,Vaše Produkty nebo Služby
+apps/erpnext/erpnext/public/js/setup_wizard.js +365,Your Products or Services,Vaše Produkty nebo Služby
 DocType: Mode of Payment,Mode of Payment,Způsob platby
+apps/erpnext/erpnext/stock/doctype/item/item.py +112,Website Image should be a public file or website URL,Webové stránky Image by mala byť verejná súboru alebo webovej stránky URL
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +31,This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.
 DocType: Journal Entry Account,Purchase Order,Vydaná objednávka
 DocType: Warehouse,Warehouse Contact Info,Sklad Kontaktní informace
@@ -1039,7 +1041,7 @@
 DocType: Serial No,Serial No Details,Serial No Podrobnosti
 DocType: Purchase Invoice Item,Item Tax Rate,Sazba daně položky
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +113,"For {0}, only credit accounts can be linked against another debit entry","Pro {0}, tak úvěrové účty mohou být propojeny na jinou položku debetní"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +470,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +477,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
 apps/erpnext/erpnext/stock/get_item_details.py +136,Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +41,Capital Equipments,Kapitálové Vybavení
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +31,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Ceny Pravidlo je nejprve vybrána na základě ""Použít na"" oblasti, které mohou být položky, položky skupiny nebo značky."
@@ -1057,9 +1059,8 @@
 DocType: Authorization Rule,Transaction,Transakce
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +45,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Poznámka: Tento Nákladové středisko je Group. Nelze vytvořit účetní zápisy proti skupinám.
 DocType: Item,Website Item Groups,Webové stránky skupiny položek
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +174,Production order number is mandatory for stock entry purpose manufacture,Výrobní číslo objednávky je povinná pro legální vstup účelem výroby
 DocType: Purchase Invoice,Total (Company Currency),Total (Company meny)
-apps/erpnext/erpnext/stock/utils.py +162,Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou
+apps/erpnext/erpnext/stock/utils.py +166,Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou
 DocType: Journal Entry,Journal Entry,Zápis do deníku
 DocType: Workstation,Workstation Name,Meno pracovnej stanice
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,E-mail Digest:
@@ -1104,7 +1105,7 @@
 DocType: Features Setup,Features Setup,Nastavení Funkcí
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,View Offer Letter,View Ponuka List
 DocType: Item,Is Service Item,Je Service Item
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81,Application period cannot be outside leave allocation period,Obdobie podávania žiadostí nemôže byť alokačné obdobie vonku voľno
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +82,Application period cannot be outside leave allocation period,Obdobie podávania žiadostí nemôže byť alokačné obdobie vonku voľno
 DocType: Activity Cost,Projects,Projekty
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +31,Please select Fiscal Year,"Prosím, vyberte Fiskální rok"
 apps/erpnext/erpnext/controllers/buying_controller.py +23,From {0} | {1} {2},Od {0} | {1} {2}
@@ -1121,7 +1122,7 @@
 DocType: Sales Order Item,Planned Quantity,Plánované Množství
 DocType: Purchase Invoice Item,Item Tax Amount,Částka Daně Položky
 DocType: Item,Maintain Stock,Udržiavať Zásoby
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +213,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 +211,Stock Entries already created for Production Order ,Fotky Položky již vytvořené pro výrobní zakázku
 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 +517,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Obvinění z typu ""Aktuální"" v řádku {0} nemůže být zařazena do položky Rate"
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +182,Max: {0},Max: {0}
@@ -1133,7 +1134,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/account.js +50,Chart of Accounts,Diagram účtů
 DocType: Material Request,Terms and Conditions Content,Podmínky Content
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +471,cannot be greater than 100,nemůže být větší než 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +557,Item {0} is not a stock Item,Položka {0} není skladem
+apps/erpnext/erpnext/stock/doctype/item/item.py +587,Item {0} is not a stock Item,Položka {0} není skladem
 DocType: Maintenance Visit,Unscheduled,Neplánovaná
 DocType: Employee,Owned,Vlastník
 DocType: Salary Slip Deduction,Depends on Leave Without Pay,Závisí na dovolenke bez nároku na mzdu
@@ -1156,19 +1157,19 @@
 DocType: Account,"If the account is frozen, entries are allowed to restricted users.","V případě, že účet je zamrzlý, položky mohou omezeným uživatelům."
 DocType: Email Digest,Bank Balance,Bank Balance
 apps/erpnext/erpnext/controllers/accounts_controller.py +453,Accounting Entry for {0}: {1} can only be made in currency: {2},Účtovný záznam pre {0}: {1} môžu vykonávať len v mene: {2}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +43,No active Salary Structure found for employee {0} and the month,Žiadny aktívny Štruktúra Plat nájdených pre zamestnancov {0} a mesiac
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +44,No active Salary Structure found for employee {0} and the month,Žiadny aktívny Štruktúra Plat nájdených pre zamestnancov {0} a mesiac
 DocType: Job Opening,"Job profile, qualifications required etc.","Profil Job, požadované kvalifikace atd."
 DocType: Journal Entry Account,Account Balance,Zůstatek na účtu
 apps/erpnext/erpnext/config/accounts.py +112,Tax Rule for transactions.,Daňové Pravidlo pre transakcie.
 DocType: Rename Tool,Type of document to rename.,Typ dokumentu přejmenovat.
-apps/erpnext/erpnext/public/js/setup_wizard.js +381,We buy this Item,Táto položka sa kupuje
+apps/erpnext/erpnext/public/js/setup_wizard.js +384,We buy this Item,Táto položka sa kupuje
 DocType: Address,Billing,Fakturace
 DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Celkem Daně a poplatky (Company Měnové)
 DocType: Shipping Rule,Shipping Account,Přepravní účtu
 apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +43,Scheduled to send to {0} recipients,Plánované poslat na {0} příjemci
 DocType: Quality Inspection,Readings,Čtení
 DocType: Stock Entry,Total Additional Costs,Celkom Dodatočné náklady
-apps/erpnext/erpnext/public/js/setup_wizard.js +374,Sub Assemblies,Podsestavy
+apps/erpnext/erpnext/public/js/setup_wizard.js +377,Sub Assemblies,Podsestavy
 DocType: Shipping Rule Condition,To Value,Chcete-li hodnota
 DocType: Supplier,Stock Manager,Reklamný manažér
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +143,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
@@ -1231,7 +1232,7 @@
 apps/erpnext/erpnext/config/stock.py +115,Brand master.,Master Značky
 DocType: Sales Invoice Item,Brand Name,Jméno značky
 DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
-apps/erpnext/erpnext/public/js/setup_wizard.js +377,Box,Krabice
+apps/erpnext/erpnext/public/js/setup_wizard.js +380,Box,Krabice
 apps/erpnext/erpnext/public/js/setup_wizard.js +137,The Organization,Organizace
 DocType: Monthly Distribution,Monthly Distribution,Měsíční Distribution
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Přijímač Seznam je prázdný. Prosím vytvořte přijímače Seznam
@@ -1247,11 +1248,11 @@
 ,POS,POS
 apps/erpnext/erpnext/config/stock.py +268,Opening Stock Balance,Otvorenie Sklad Balance
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +36,{0} must appear only once,{0} môže byť uvedené iba raz
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +334,Not allowed to tranfer more {0} than {1} against Purchase Order {2},"Nie je povolené, aby transfer viac {0} ako {1} proti objednanie {2}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +332,Not allowed to tranfer more {0} than {1} against Purchase Order {2},"Nie je povolené, aby transfer viac {0} ako {1} proti objednanie {2}"
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +62,Leaves Allocated Successfully for {0},Listy Přidělené úspěšně za {0}
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +40,No Items to pack,Žádné položky k balení
 DocType: Shipping Rule Condition,From Value,Od hodnoty
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +552,Manufacturing Quantity is mandatory,Výrobní množství je povinné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +550,Manufacturing Quantity is mandatory,Výrobní množství je povinné
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Amounts not reflected in bank,Částky nezohledněny v bance
 DocType: Quality Inspection Reading,Reading 4,Čtení 4
 apps/erpnext/erpnext/config/hr.py +23,Claims for company expense.,Nároky na náklady firmy.
@@ -1261,13 +1262,13 @@
 DocType: Opportunity,Contact Mobile No,Kontakt Mobil
 DocType: Production Planning Tool,Select Sales Orders,Vyberte Prodejní objednávky
 ,Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +117,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"V deň, keď (y), na ktoré žiadate o povolenie sú prázdniny. Nemusíte požiadať o voľno."
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +118,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"V deň, keď (y), na ktoré žiadate o povolenie sú prázdniny. Nemusíte požiadať o voľno."
 DocType: Features Setup,To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Chcete-li sledovat položky pomocí čárového kódu. Budete mít možnost zadat položky dodacího listu a prodejní faktury snímáním čárového kódu položky.
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +588,Mark as Delivered,Označiť ako Dodáva
 apps/erpnext/erpnext/crm/doctype/lead/lead.js +34,Make Quotation,Značka Citácia
 DocType: Dependent Task,Dependent Task,Závislý Task
-apps/erpnext/erpnext/stock/doctype/item/item.py +310,Conversion factor for default Unit of Measure must be 1 in row {0},"Konverzní faktor pro výchozí měrnou jednotku, musí být 1 v řádku {0}"
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +155,Leave of type {0} cannot be longer than {1},Leave typu {0} nemůže být delší než {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +340,Conversion factor for default Unit of Measure must be 1 in row {0},"Konverzní faktor pro výchozí měrnou jednotku, musí být 1 v řádku {0}"
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +157,Leave of type {0} cannot be longer than {1},Leave typu {0} nemůže být delší než {1}
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,Skúste plánovanie operácií pre X dní vopred.
 DocType: HR Settings,Stop Birthday Reminders,Zastavit připomenutí narozenin
 DocType: SMS Center,Receiver List,Přijímač Seznam
@@ -1275,7 +1276,7 @@
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Spotřebovaném množství
 apps/erpnext/erpnext/public/js/pos/pos.js +491,{0} View,{0} Zobraziť
 DocType: Salary Structure Deduction,Salary Structure Deduction,Plat Struktura Odpočet
-apps/erpnext/erpnext/stock/doctype/item/item.py +305,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Měrná jednotka {0} byl zadán více než jednou v konverzním faktorem tabulce
+apps/erpnext/erpnext/stock/doctype/item/item.py +335,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Měrná jednotka {0} byl zadán více než jednou v konverzním faktorem tabulce
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Náklady na vydaných položek
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +185,Quantity must not be more than {0},Množství nesmí být větší než {0}
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +41,Age (Days),Staroba (dni)
@@ -1344,13 +1345,13 @@
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +50,"Company, Month and Fiscal Year is mandatory","Společnost, měsíc a fiskální rok je povinný"
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Marketing Expenses,Marketingové náklady
 ,Item Shortage Report,Položka Nedostatek Report
-apps/erpnext/erpnext/stock/doctype/item/item.js +185,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnost je uvedeno, \n uveďte prosím ""váha UOM"" příliš"
+apps/erpnext/erpnext/stock/doctype/item/item.js +200,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnost je uvedeno, \n uveďte prosím ""váha UOM"" příliš"
 DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materiál Žádost používá k výrobě této populace Entry
 apps/erpnext/erpnext/config/support.py +43,Single unit of an Item.,Single jednotka položky.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +212,Time Log Batch {0} must be 'Submitted',"Time Log Batch {0} musí být ""Odesláno"""
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +213,Time Log Batch {0} must be 'Submitted',"Time Log Batch {0} musí být ""Odesláno"""
 DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Ujistěte se účetní položka pro každý pohyb zásob
 DocType: Leave Allocation,Total Leaves Allocated,Celkem Leaves Přidělené
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +386,Warehouse required at Row No {0},Warehouse vyžadované pri Row No {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +387,Warehouse required at Row No {0},Warehouse vyžadované pri Row No {0}
 apps/erpnext/erpnext/public/js/setup_wizard.js +169,Please enter valid Financial Year Start and End Dates,Zadajte platnú finančný rok dátum začatia a ukončenia
 DocType: Employee,Date Of Retirement,Datum odchodu do důchodu
 DocType: Upload Attendance,Get Template,Získat šablonu
@@ -1362,7 +1363,7 @@
 DocType: Territory,Parent Territory,Parent Territory
 DocType: Quality Inspection Reading,Reading 2,Čtení 2
 DocType: Stock Entry,Material Receipt,Příjem materiálu
-apps/erpnext/erpnext/public/js/setup_wizard.js +373,Products,Výrobky
+apps/erpnext/erpnext/public/js/setup_wizard.js +376,Products,Výrobky
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +47,Party Type and Party is required for Receivable / Payable account {0},Zadejte Party Party a je nutné pro pohledávky / závazky na účtu {0}
 DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ak je táto položka má varianty, potom to nemôže byť vybraná v predajných objednávok atď"
 DocType: Lead,Next Contact By,Další Kontakt By
@@ -1375,10 +1376,10 @@
 apps/erpnext/erpnext/public/js/setup_wizard.js +147,"e.g. ""XYZ National Bank""","napríklad ""XYZ Národná Banka"""
 DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +61,Total Target,Celkem Target
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.js +22,Shopping Cart is enabled,Nákupný košík je povolené
+apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.js +29,Shopping Cart is enabled,Nákupný košík je povolené
 DocType: Job Applicant,Applicant for a Job,Žadatel o zaměstnání
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +173,No Production Orders created,Žádné výrobní zakázky vytvořené
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +145,Salary Slip of employee {0} already created for this month,Plat Slip of zaměstnance {0} již vytvořili pro tento měsíc
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +153,Salary Slip of employee {0} already created for this month,Plat Slip of zaměstnance {0} již vytvořili pro tento měsíc
 DocType: Stock Reconciliation,Reconciliation JSON,Odsouhlasení JSON
 apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Příliš mnoho sloupců. Export zprávu a vytiskněte jej pomocí aplikace tabulky.
 DocType: Sales Invoice Item,Batch No,Č. šarže
@@ -1387,13 +1388,13 @@
 apps/erpnext/erpnext/stock/doctype/item/item_list.js +13,Variant,Varianta
 DocType: Naming Series,Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakcí
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +164,Stopped order cannot be cancelled. Unstop to cancel.,Zastaveno příkaz nelze zrušit. Uvolnit zrušit.
-apps/erpnext/erpnext/stock/doctype/item/item.py +327,Default BOM ({0}) must be active for this item or its template,Predvolené BOM ({0}) musí byť aktívna pre túto položku alebo jeho šablóny
+apps/erpnext/erpnext/stock/doctype/item/item.py +357,Default BOM ({0}) must be active for this item or its template,Predvolené BOM ({0}) musí byť aktívna pre túto položku alebo jeho šablóny
 DocType: Employee,Leave Encashed?,Ponechte zpeněžení?
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Opportunity Ze hřiště je povinné
 DocType: Item,Variants,Varianty
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +545,Make Purchase Order,Proveďte objednávky
 DocType: SMS Center,Send To,Odeslat
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +127,There is not enough leave balance for Leave Type {0},Není dost bilance dovolenou na vstup typ {0}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +129,There is not enough leave balance for Leave Type {0},Není dost bilance dovolenou na vstup typ {0}
 DocType: Payment Reconciliation Payment,Allocated amount,Přidělené sumy
 DocType: Sales Team,Contribution to Net Total,Příspěvek na celkových čistých
 DocType: Sales Invoice Item,Customer's Item Code,Zákazníka Kód položky
@@ -1426,7 +1427,7 @@
 DocType: Sales Order Item,Actual Qty,Skutečné Množství
 DocType: Sales Invoice Item,References,Referencie
 DocType: Quality Inspection Reading,Reading 10,Čtení 10
-apps/erpnext/erpnext/public/js/setup_wizard.js +363,"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Seznam vaše produkty nebo služby, které jste koupit nebo prodat. Ujistěte se, že zkontrolovat položky Group, měrná jednotka a dalších vlastností při spuštění."
+apps/erpnext/erpnext/public/js/setup_wizard.js +366,"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.","Seznam vaše produkty nebo služby, které jste koupit nebo prodat. Ujistěte se, že zkontrolovat položky Group, měrná jednotka a dalších vlastností při spuštění."
 DocType: Hub Settings,Hub Node,Hub Node
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,"Zadali jste duplicitní položky. Prosím, opravu a zkuste to znovu."
 apps/erpnext/erpnext/controllers/item_variant.py +65,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values,Hodnota {0} pre atribút {1} neexistuje v zozname platného bodu Hodnoty atribútov
@@ -1455,6 +1456,7 @@
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Položka {0} se objeví několikrát v Ceníku {1}
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,"Selling must be checked, if Applicable For is selected as {0}","Prodej musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
 DocType: Purchase Order Item,Supplier Quotation Item,Položka dodávateľskej ponuky
+DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Zakáže vytváranie časových protokolov proti výrobnej zákazky. Transakcie nesmú byť sledované proti výrobnej zákazky
 apps/erpnext/erpnext/hr/doctype/employee/employee.js +27,Make Salary Structure,Proveďte platovou strukturu
 DocType: Item,Has Variants,Má varianty
 apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +22,Click on 'Make Sales Invoice' button to create a new Sales Invoice.,"Klikněte na tlačítko "", aby se prodej na faktuře"" vytvořit nový prodejní faktury."
@@ -1469,7 +1471,7 @@
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +41,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Rozpočet nemožno priradiť proti {0}, pretože to nie je výnos alebo náklad účet"
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Dosažená
 apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +65,Territory / Customer,Territory / Customer
-apps/erpnext/erpnext/public/js/setup_wizard.js +309,e.g. 5,napríklad 5
+apps/erpnext/erpnext/public/js/setup_wizard.js +312,e.g. 5,napríklad 5
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +154,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: Přidělená částka {1} musí být menší než nebo se rovná fakturovat dlužné částky {2}
 DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,"Ve slovech budou viditelné, jakmile uložíte prodejní faktury."
 DocType: Item,Is Sales Item,Je Sales Item
@@ -1477,7 +1479,7 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,"Položka {0} není nastavení pro Serial č. Zkontrolujte, zda master položku"
 DocType: Maintenance Visit,Maintenance Time,Údržba Time
 ,Amount to Deliver,"Suma, ktorá má dodávať"
-apps/erpnext/erpnext/public/js/setup_wizard.js +371,A Product or Service,Produkt nebo Služba
+apps/erpnext/erpnext/public/js/setup_wizard.js +374,A Product or Service,Produkt nebo Služba
 DocType: Naming Series,Current Value,Current Value
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +171,{0} created,{0} vytvoril
 DocType: Delivery Note Item,Against Sales Order,Proti přijaté objednávce
@@ -1507,14 +1509,14 @@
 DocType: Installation Note,Installation Time,Instalace Time
 DocType: Sales Invoice,Accounting Details,Účtovné Podrobnosti
 apps/erpnext/erpnext/setup/doctype/company/company.js +44,Delete all the Transactions for this Company,Odstráňte všetky transakcie pre túto spoločnosť
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +191,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 +189,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 +57,Investments,Investice
 DocType: Issue,Resolution Details,Rozlišení Podrobnosti
 DocType: Quality Inspection Reading,Acceptance Criteria,Kritéria přijetí
 DocType: Item Attribute,Attribute Name,Název atributu
 apps/erpnext/erpnext/controllers/selling_controller.py +236,Item {0} must be Sales or Service Item in {1},Položka {0} musí být prodej či servis položku v {1}
 DocType: Item Group,Show In Website,Show pro webové stránky
-apps/erpnext/erpnext/public/js/setup_wizard.js +372,Group,Skupina
+apps/erpnext/erpnext/public/js/setup_wizard.js +375,Group,Skupina
 DocType: Task,Expected Time (in hours),Predpokladaná doba (v hodinách)
 ,Qty to Order,Množství k objednávce
 DocType: Features Setup,"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Product Bundle, Sales Order, Serial No","Ak chcete sledovať značku v nasledujúcich dokumentoch dodacom liste Opportunity, materiál Request, položka, objednávke, kúpnej poukazu, nakupujú potvrdenka, cenovú ponuku, predajné faktúry, Product Bundle, predajné objednávky, poradové číslo"
@@ -1524,14 +1526,14 @@
 DocType: Features Setup,Brands,Značky
 DocType: C-Form Invoice Detail,Invoice No,Faktúra č.
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +567,From Purchase Order,Z vydané objednávky
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Nechajte nemožno aplikovať / zrušená pred {0}, pretože rovnováha dovolenky už bolo carry-odovzdávané v budúcej pridelenie dovolenku záznamu {1}"
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +93,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Nechajte nemožno aplikovať / zrušená pred {0}, pretože rovnováha dovolenky už bolo carry-odovzdávané v budúcej pridelenie dovolenku záznamu {1}"
 DocType: Activity Cost,Costing Rate,Kalkulácie Rate
 ,Customer Addresses And Contacts,Adresy zákazníkov a kontakty
 DocType: Employee,Resignation Letter Date,Rezignace Letter Datum
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +37,Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Repeat Customer Příjmy
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +51,{0} ({1}) must have role 'Expense Approver',"{0} ({1}), musí mať úlohu ""Schvalovateľ výdajov"""
-apps/erpnext/erpnext/public/js/setup_wizard.js +377,Pair,Pár
+apps/erpnext/erpnext/public/js/setup_wizard.js +380,Pair,Pár
 DocType: Bank Reconciliation Detail,Against Account,Proti účet
 DocType: Maintenance Schedule Detail,Actual Date,Skutečné datum
 DocType: Item,Has Batch No,Má číslo šarže
@@ -1540,7 +1542,7 @@
 ,Maintenance Schedules,Plány údržby
 ,Quotation Trends,Vývoje ponúk
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +139,Item Group not mentioned in item master for item {0},Položka Group není uvedeno v položce mistra na položku {0}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +302,Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +303,Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
 DocType: Shipping Rule Condition,Shipping Amount,Přepravní Částka
 ,Pending Amount,Čeká Částka
 DocType: Purchase Invoice Item,Conversion Factor,Konverzní faktor
@@ -1557,7 +1559,7 @@
 apps/erpnext/erpnext/config/accounts.py +41,Tree of finanial accounts.,Strom finanial účtů.
 DocType: Leave Control Panel,Leave blank if considered for all employee types,"Ponechte prázdné, pokud se to považuje za ubytování ve všech typech zaměstnanců"
 DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuovat poplatků na základě
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +312,Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,"Účet {0} musí být typu ""dlouhodobého majetku"", protože položka {1} je majetková položka"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +313,Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,"Účet {0} musí být typu ""dlouhodobého majetku"", protože položka {1} je majetková položka"
 DocType: HR Settings,HR Settings,Nastavení HR
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +114,Expense Claim is pending approval. Only the Expense Approver can update status.,Úhrada výdajů čeká na schválení. Pouze schalovatel výdajů může aktualizovat stav.
 DocType: Purchase Invoice,Additional Discount Amount,Dodatočná zľava Suma
@@ -1565,7 +1567,7 @@
 apps/erpnext/erpnext/setup/doctype/company/company.py +236,Abbr can not be blank or space,Skrátená nemôže byť prázdne alebo priestor
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,Sportovní
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +61,Total Actual,Celkem Aktuální
-apps/erpnext/erpnext/public/js/setup_wizard.js +377,Unit,Jednotka
+apps/erpnext/erpnext/public/js/setup_wizard.js +380,Unit,Jednotka
 apps/erpnext/erpnext/stock/get_item_details.py +113,Please specify Company,"Uveďte prosím, firmu"
 ,Customer Acquisition and Loyalty,Zákazník Akvizice a loajality
 DocType: Purchase Receipt,Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek"
@@ -1600,7 +1602,7 @@
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +82,Item {0} has already been returned,Bod {0} již byla vrácena
 DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiškálny rok ** predstavuje finančný rok. Všetky účtovné záznamy a ďalšie významné transakcie sú sledované pod ** Fiškálny rok **.
 DocType: Opportunity,Customer / Lead Address,Zákazník / Iniciatíva Adresa
-apps/erpnext/erpnext/stock/doctype/item/item.py +112,Warning: Invalid SSL certificate on attachment {0},Varovanie: Neplatný certifikát SSL na prílohu {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +142,Warning: Invalid SSL certificate on attachment {0},Varovanie: Neplatný certifikát SSL na prílohu {0}
 DocType: Production Order Operation,Actual Operation Time,Aktuální Provozní doba
 DocType: Authorization Rule,Applicable To (User),Vztahující se na (Uživatel)
 DocType: Purchase Taxes and Charges,Deduct,Odečíst
@@ -1635,7 +1637,7 @@
 apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +36,Select Company...,Vyberte společnost ...
 DocType: Leave Control Panel,Leave blank if considered for all departments,"Ponechte prázdné, pokud se to považuje za všechna oddělení"
 apps/erpnext/erpnext/config/hr.py +95,"Types of employment (permanent, contract, intern etc.).","Druhy pracovního poměru (trvalý, smluv, stážista atd.)"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +355,{0} is mandatory for Item {1},{0} je povinná k položke {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +356,{0} is mandatory for Item {1},{0} je povinná k položke {1}
 DocType: Currency Exchange,From Currency,Od Měny
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosím, vyberte alokovaná částka, typ faktury a číslo faktury v aspoň jedné řadě"
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +107,Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0}
@@ -1648,7 +1650,7 @@
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +94,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Bankovnictví
 apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +38,Please click on 'Generate Schedule' to get schedule,"Prosím, klikněte na ""Generovat Schedule"", aby se plán"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +297,New Cost Center,Nové Nákladové Středisko
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +300,New Cost Center,Nové Nákladové Středisko
 DocType: Bin,Ordered Quantity,Objednané množství
 apps/erpnext/erpnext/public/js/setup_wizard.js +145,"e.g. ""Build tools for builders""","napríklad ""Nástroje pre stavbárov """
 DocType: Quality Inspection,In Process,V procesu
@@ -1664,7 +1666,7 @@
 apps/erpnext/erpnext/config/selling.py +299,Sales Order to Payment,Predajné objednávky na platby
 DocType: Expense Claim Detail,Expense Claim Detail,Detail úhrady výdajů
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +271,Time Logs created:,Čas Záznamy vytvořil:
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +756,Please select correct account,"Prosím, vyberte správny účet"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +761,Please select correct account,"Prosím, vyberte správny účet"
 DocType: Item,Weight UOM,Hmotnostná MJ
 DocType: Employee,Blood Group,Krevní Skupina
 DocType: Purchase Invoice Item,Page Break,Zalomení stránky
@@ -1709,7 +1711,7 @@
 DocType: Quality Inspection,Sample Size,Velikost vzorku
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +446,All items have already been invoiced,Všechny položky již byly fakturovány
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +47,Please specify a valid 'From Case No.',"Uveďte prosím platný ""Od věci č '"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +301,Further cost centers can be made under Groups but entries can be made against non-Groups,"Ďalšie nákladové strediská môžu byť vyrobené v rámci skupiny, ale položky môžu byť vykonané proti non-skupín"
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +304,Further cost centers can be made under Groups but entries can be made against non-Groups,"Ďalšie nákladové strediská môžu byť vyrobené v rámci skupiny, ale položky môžu byť vykonané proti non-skupín"
 DocType: Project,External,Externí
 DocType: Features Setup,Item Serial Nos,Položka sériových čísel
 apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Uživatelé a oprávnění
@@ -1719,7 +1721,7 @@
 DocType: Bin,Actual Quantity,Skutečné Množství
 DocType: Shipping Rule,example: Next Day Shipping,Příklad: Next Day Shipping
 apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +188,Serial No {0} not found,Pořadové číslo {0} nebyl nalezen
-apps/erpnext/erpnext/public/js/setup_wizard.js +318,Your Customers,Vaši Zákazníci
+apps/erpnext/erpnext/public/js/setup_wizard.js +321,Your Customers,Vaši Zákazníci
 DocType: Leave Block List Date,Block Date,Block Datum
 DocType: Sales Order,Not Delivered,Ne vyhlášeno
 ,Bank Clearance Summary,Souhrn bankovního zúčtování
@@ -1769,7 +1771,7 @@
 DocType: Naming Series,User must always select,Uživatel musí vždy vybrat
 DocType: Stock Settings,Allow Negative Stock,Povolit Negativní Sklad
 DocType: Installation Note,Installation Note,Poznámka k instalaci
-apps/erpnext/erpnext/public/js/setup_wizard.js +298,Add Taxes,Pridajte dane
+apps/erpnext/erpnext/public/js/setup_wizard.js +301,Add Taxes,Pridajte dane
 ,Financial Analytics,Finanční Analýza
 DocType: Quality Inspection,Verified By,Verified By
 DocType: Address,Subsidiary,Dceřiný
@@ -1779,7 +1781,7 @@
 DocType: Process Payroll,Create Salary Slip,Vytvořit výplatní pásce
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +53,Expected balance as per bank,Očekávaný zůstatek podle banky
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +158,Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +347,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +345,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
 DocType: Appraisal,Employee,Zaměstnanec
 apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +10,Import Email From,Importovať e-maily z
 apps/erpnext/erpnext/utilities/doctype/contact/contact.js +67,Invite as User,Pozvať ako Užívateľ
@@ -1820,10 +1822,11 @@
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +145,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemôže byť väčšie, ako plánované množstvo ({2}), vo Výrobnej Objednávke {3}"
 DocType: Shipping Rule,Shipping Rule Label,Přepravní Pravidlo Label
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204,Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +418,"Could not update stock, invoice contains drop shipping item.","Nie je možné aktualizovať zásob, faktúra obsahuje pokles lodnej dopravy tovaru."
 DocType: Newsletter,Test,Test
-apps/erpnext/erpnext/stock/doctype/item/item.py +368,"As there are existing stock transactions for this item, \
+apps/erpnext/erpnext/stock/doctype/item/item.py +398,"As there are existing stock transactions for this item, \
 							you can not change the values of 'Has Serial No', 'Has Batch No', 'Is Stock Item' and 'Valuation Method'","Ako tam sú existujúce skladové transakcie pre túto položku, \ nemôžete zmeniť hodnoty &quot;Má sériové číslo&quot;, &quot;má Batch Nie&quot;, &quot;Je skladom&quot; a &quot;ocenenie Method&quot;"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +448,Quick Journal Entry,Rýchly vstup Journal
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +444,Quick Journal Entry,Rýchly vstup Journal
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +100,You can not change rate if BOM mentioned agianst any item,"Nemůžete změnit sazbu, kdyby BOM zmínil agianst libovolné položky"
 DocType: Employee,Previous Work Experience,Předchozí pracovní zkušenosti
 DocType: Stock Entry,For Quantity,Pre Množstvo
@@ -1841,7 +1844,7 @@
 DocType: Authorization Rule,Authorized Value,Autorizovaný Hodnota
 DocType: Contact,Enter department to which this Contact belongs,"Zadejte útvar, který tento kontaktní patří"
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +57,Total Absent,Celkem Absent
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +746,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 +744,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 +104,Unit of Measure,Měrná jednotka
 DocType: Fiscal Year,Year End Date,Dátum konca roka
 DocType: Task Depends On,Task Depends On,Úloha je závislá na
@@ -1939,7 +1942,7 @@
 DocType: Purchase Taxes and Charges,Parenttype,Parenttype
 DocType: Salary Structure,Total Earning,Celkem Zisk
 DocType: Purchase Receipt,Time at which materials were received,"Čas, kdy bylo přijato materiály"
-apps/erpnext/erpnext/utilities/doctype/address/address.py +113,My Addresses,Moje Adresy
+apps/erpnext/erpnext/utilities/doctype/address/address.py +118,My Addresses,Moje Adresy
 DocType: Stock Ledger Entry,Outgoing Rate,Odchádzajúce Rate
 apps/erpnext/erpnext/config/hr.py +100,Organization branch master.,Organizace větev master.
 apps/erpnext/erpnext/controllers/accounts_controller.py +255, or ,alebo
@@ -1956,6 +1959,7 @@
 DocType: Purchase Invoice,Total Taxes and Charges,Celkem Daně a poplatky
 DocType: Employee,Emergency Contact,Kontakt v nouzi
 DocType: Item,Quality Parameters,Parametry kvality
+apps/erpnext/erpnext/stock/doctype/item/item.js +26,Ledger,Účetní kniha
 DocType: Target Detail,Target  Amount,Cílová částka
 DocType: Shopping Cart Settings,Shopping Cart Settings,Nastavenie Nákupného košíka
 DocType: Journal Entry,Accounting Entries,Účetní záznamy
@@ -2006,9 +2010,9 @@
 DocType: Company,Stock Settings,Nastavenie Skladu
 apps/erpnext/erpnext/accounts/doctype/account/account.py +201,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojenie je možné len vtedy, ak tieto vlastnosti sú rovnaké v oboch záznamoch. Je Group, Root Type, Company"
 apps/erpnext/erpnext/config/crm.py +72,Manage Customer Group Tree.,Správa zákazníků skupiny Tree.
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +299,New Cost Center Name,Jméno Nového Nákladového Střediska
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +302,New Cost Center Name,Jméno Nového Nákladového Střediska
 DocType: Leave Control Panel,Leave Control Panel,Nechte Ovládací panely
-apps/erpnext/erpnext/utilities/doctype/address/address.py +90,No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,"No default šablony adresy nalezeno. Prosím, vytvořte nový z Nastavení> Tisk a značky> Adresa šablonu."
+apps/erpnext/erpnext/utilities/doctype/address/address.py +95,No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,"No default šablony adresy nalezeno. Prosím, vytvořte nový z Nastavení> Tisk a značky> Adresa šablonu."
 DocType: Appraisal,HR User,HR User
 DocType: Purchase Invoice,Taxes and Charges Deducted,Daně a odečtené
 apps/erpnext/erpnext/shopping_cart/utils.py +46,Issues,Problémy
@@ -2044,7 +2048,7 @@
 DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Všechny prodejní transakce mohou být označeny proti více ** prodejcům **, takže si můžete nastavit a sledovat cíle."
 ,S.O. No.,SO Ne.
 DocType: Production Order Operation,Make Time Log,Udělejte si čas Přihlásit
-apps/erpnext/erpnext/stock/doctype/item/item.py +382,Please set reorder quantity,Prosím nastavte množstvo objednávacie
+apps/erpnext/erpnext/stock/doctype/item/item.py +412,Please set reorder quantity,Prosím nastavte množstvo objednávacie
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +158,Please create Customer from Lead {0},Prosím vytvorte Zákazníka z Obchodnej iniciatívy {0}
 DocType: Price List,Applicable for Countries,Pre krajiny
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Computers,Počítače
@@ -2128,9 +2132,9 @@
 DocType: Purchase Invoice,Half-yearly,Pololetní
 apps/erpnext/erpnext/accounts/report/financial_statements.py +16,Fiscal Year {0} not found.,Fiskální rok {0} nebyl nalezen.
 DocType: Bank Reconciliation,Get Relevant Entries,Získat příslušné zápisy
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407,Accounting Entry for Stock,Účetní položka na skladě
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +405,Accounting Entry for Stock,Účetní položka na skladě
 DocType: Sales Invoice,Sales Team1,Sales Team1
-apps/erpnext/erpnext/stock/doctype/item/item.py +423,Item {0} does not exist,Bod {0} neexistuje
+apps/erpnext/erpnext/stock/doctype/item/item.py +453,Item {0} does not exist,Bod {0} neexistuje
 DocType: Sales Invoice,Customer Address,Zákazník Address
 DocType: Purchase Invoice,Apply Additional Discount On,Použiť dodatočné Zľava na
 DocType: Account,Root Type,Root Type
@@ -2169,7 +2173,7 @@
 DocType: Purchase Invoice Item,Valuation Rate,Ocenění Rate
 apps/erpnext/erpnext/stock/get_item_details.py +281,Price List Currency not selected,Ceníková Měna není zvolena
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,"Bod Row {0}: doklad o koupi, {1} neexistuje v tabulce ""kupní příjmy"""
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +145,Employee {0} has already applied for {1} between {2} and {3},Zaměstnanec {0} již požádal o {1} mezi {2} a {3}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +147,Employee {0} has already applied for {1} between {2} and {3},Zaměstnanec {0} již požádal o {1} mezi {2} a {3}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Datum zahájení projektu
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +8,Until,Dokud
 DocType: Rename Tool,Rename Log,Přejmenovat Přihlásit
@@ -2204,7 +2208,7 @@
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +127,Please enter relieving date.,Zadejte zmírnění datum.
 apps/erpnext/erpnext/controllers/trends.py +137,Amt,Amt
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +51,Only Leave Applications with status 'Approved' can be submitted,"Nechte pouze aplikace s status ""schváleno"" může být předloženy"
-apps/erpnext/erpnext/utilities/doctype/address/address.py +21,Address Title is mandatory.,Adresa Název je povinný.
+apps/erpnext/erpnext/utilities/doctype/address/address.py +24,Address Title is mandatory.,Adresa Název je povinný.
 DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Zadejte název kampaně, pokud zdroj šetření je kampaň"
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +38,Newspaper Publishers,Vydavatelé novin
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +31,Select Fiscal Year,Vyberte Fiskální rok
@@ -2216,7 +2220,7 @@
 DocType: Purchase Receipt Item,Accepted Warehouse,Schválené Sklad
 DocType: Bank Reconciliation Detail,Posting Date,Datum zveřejnění
 DocType: Item,Valuation Method,Ocenění Method
-apps/erpnext/erpnext/setup/utils.py +88,Unable to find exchange rate for {0} to {1},Nepodarilo sa nájsť kurz pre {0} do {1}
+apps/erpnext/erpnext/setup/utils.py +91,Unable to find exchange rate for {0} to {1},Nepodarilo sa nájsť kurz pre {0} do {1}
 DocType: Sales Invoice,Sales Team,Prodejní tým
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +88,Duplicate entry,Duplicitní záznam
 DocType: Serial No,Under Warranty,V rámci záruky
@@ -2295,7 +2299,7 @@
 DocType: Bank Reconciliation,Bank Reconciliation,Bank Odsouhlasení
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +9,Get Updates,Získať aktualizácie
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +106,Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena
-apps/erpnext/erpnext/public/js/setup_wizard.js +392,Add a few sample records,Pridať niekoľko ukážkových záznamov
+apps/erpnext/erpnext/public/js/setup_wizard.js +395,Add a few sample records,Pridať niekoľko ukážkových záznamov
 apps/erpnext/erpnext/config/hr.py +210,Leave Management,Nechajte Správa
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +81,Group by Account,Seskupit podle účtu
 DocType: Sales Order,Fully Delivered,Plně Dodáno
@@ -2314,7 +2318,7 @@
 DocType: Sales Order,Customer's Purchase Order,Zákazníka Objednávka
 DocType: Warranty Claim,From Company,Od Společnosti
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +95,Value or Qty,Hodnota nebo Množství
-apps/erpnext/erpnext/public/js/setup_wizard.js +378,Minute,Minuta
+apps/erpnext/erpnext/public/js/setup_wizard.js +381,Minute,Minuta
 DocType: Purchase Invoice,Purchase Taxes and Charges,Nákup Daně a poplatky
 ,Qty to Receive,Množství pro příjem
 DocType: Leave Block List,Leave Block List Allowed,Nechte Block List povolena
@@ -2335,7 +2339,7 @@
 DocType: Appraisal,Appraisal,Ocenění
 apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +22,Date is repeated,Datum se opakuje
 apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Prokurista
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +162,Leave approver must be one of {0},Nechte Schvalující musí být jedním z {0}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +164,Leave approver must be one of {0},Nechte Schvalující musí být jedním z {0}
 DocType: Hub Settings,Seller Email,Prodávající E-mail
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Celkové obstarávacie náklady (cez nákupné faktúry)
 DocType: Workstation Working Hour,Start Time,Start Time
@@ -2388,9 +2392,9 @@
 DocType: Project,Total Costing Amount (via Time Logs),Celková kalkulácie Čiastka (cez Time Záznamy)
 DocType: Purchase Order Item Supplied,Stock UOM,Skladová MJ
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +198,Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána
-,Projected,Plánovaná
+apps/erpnext/erpnext/stock/doctype/item/item.js +32,Projected,Plánovaná
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,Serial No {0} does not belong to Warehouse {1},Pořadové číslo {0} nepatří do skladu {1}
-apps/erpnext/erpnext/controllers/status_updater.py +136,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Poznámka: Systém nebude kontrolovat přes dobírku a over-rezervace pro item {0} jako množství nebo částka je 0
+apps/erpnext/erpnext/controllers/status_updater.py +137,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Poznámka: Systém nebude kontrolovat přes dobírku a over-rezervace pro item {0} jako množství nebo částka je 0
 DocType: Notification Control,Quotation Message,Správa k ponuke
 DocType: Issue,Opening Date,Datum otevření
 DocType: Journal Entry,Remark,Poznámka
@@ -2406,7 +2410,7 @@
 apps/erpnext/erpnext/public/js/pos/pos.html +28,Discount Amount,Částka slevy
 DocType: Purchase Invoice,Return Against Purchase Invoice,Návrat proti nákupnej faktúry
 DocType: Item,Warranty Period (in days),Záruční doba (ve dnech)
-apps/erpnext/erpnext/public/js/setup_wizard.js +307,e.g. VAT,napríklad DPH
+apps/erpnext/erpnext/public/js/setup_wizard.js +310,e.g. VAT,napríklad DPH
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Bod 4
 DocType: Journal Entry Account,Journal Entry Account,Zápis do deníku Účet
 DocType: Shopping Cart Settings,Quotation Series,Číselná rada ponúk
@@ -2437,7 +2441,7 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,Min Qty can not be greater than Max Qty,Min množství nemůže být větší než Max Množství
 DocType: Stock Entry,Customer or Supplier Details,Zákazníka alebo dodávateľa Podrobnosti
 DocType: Lead,Lead Owner,Získateľ Obchodnej iniciatívy
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +254,Warehouse is required,Je potrebná Warehouse
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +257,Warehouse is required,Je potrebná Warehouse
 DocType: Employee,Marital Status,Rodinný stav
 DocType: Stock Settings,Auto Material Request,Auto materiálu Poptávka
 DocType: Time Log,Will be updated when billed.,Bude aktualizována při účtovány.
@@ -2463,7 +2467,7 @@
 apps/erpnext/erpnext/config/crm.py +37,"Record of all communications of type email, phone, chat, visit, etc.","Záznam všetkých oznámení typu e-mail, telefón, chát, návštevy, atď"
 apps/erpnext/erpnext/accounts/general_ledger.py +134,Please mention Round Off Cost Center in Company,"Prosím, uveďte zaokrúhliť nákladové stredisko v spoločnosti"
 DocType: Purchase Invoice,Terms,Podmínky
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +248,Create New,Vytvořit nový
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +251,Create New,Vytvořit nový
 DocType: Buying Settings,Purchase Order Required,Vydaná objednávka je vyžadována
 ,Item-wise Sales History,Item-moudrý Sales History
 DocType: Expense Claim,Total Sanctioned Amount,Celková částka potrestána
@@ -2476,7 +2480,7 @@
 ,Stock Ledger,Reklamní Ledger
 apps/erpnext/erpnext/templates/pages/order.html +58,Rate: {0},Sadzba: {0}
 DocType: Salary Slip Deduction,Salary Slip Deduction,Plat Slip Odpočet
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +199,Select a group node first.,Vyberte první uzel skupinu.
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +202,Select a group node first.,Vyberte první uzel skupinu.
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +74,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 +108,Fill the form and save it,Vyplňte formulář a uložte jej
 DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,"Stáhněte si zprávu, která obsahuje všechny suroviny s jejich aktuální stav zásob"
@@ -2495,7 +2499,7 @@
 DocType: Task,depends_on,záleží na
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +86,Opportunity Lost,Příležitost Ztracena
 DocType: Features Setup,"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Sleva Pole bude k dispozici v objednávce, doklad o koupi, nákupní faktury"
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +208,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Názov nového účtu. Poznámka: Prosím, vytvárať účty pre zákazníkov a dodávateľmi"
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +211,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Názov nového účtu. Poznámka: Prosím, vytvárať účty pre zákazníkov a dodávateľmi"
 DocType: BOM Replace Tool,BOM Replace Tool,BOM Nahradit Tool
 apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Země moudrý výchozí adresa Templates
 DocType: Sales Order Item,Supplier delivers to Customer,Dodávateľ doručí zákazníkovi
@@ -2515,9 +2519,9 @@
 apps/erpnext/erpnext/config/accounts.py +79,Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +100,Please enter 'Expected Delivery Date',"Prosím, zadejte ""Očekávaná Datum dodání"""
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +182,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dodací listy {0} musí být zrušena před zrušením této prodejní objednávky
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +373,Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +374,Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} nie je platné číslo Šarže pre Položku {1}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +124,Note: There is not enough leave balance for Leave Type {0},Poznámka: Není k dispozici dostatek zůstatek dovolené dovolená za kalendářní typ {0}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +126,Note: There is not enough leave balance for Leave Type {0},Poznámka: Není k dispozici dostatek zůstatek dovolené dovolená za kalendářní typ {0}
 apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +9,"Note: If payment is not made against any reference, make Journal Entry manually.","Poznámka: Není-li platba provedena proti jakémukoli rozhodnutí, jak položka deníku ručně."
 DocType: Item,Supplier Items,Dodavatele položky
 DocType: Opportunity,Opportunity Type,Typ Příležitosti
@@ -2532,24 +2536,24 @@
 apps/erpnext/erpnext/controllers/accounts_controller.py +218,{0} '{1}' is disabled,{0} '{1}' je vypnuté
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Nastaviť ako Otvoriť
 DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Posílat automatické e-maily na Kontakty na předložení transakcí.
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +232,"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +230,"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
 					Available Qty: {4}, Transfer Qty: {5}","Row {0}: Množství nejsou dostupné iv skladu {1} na {2} {3}.
  Dispozici Množství: {4}, transfer Množství: {5}"
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Položka 3
 DocType: Purchase Order,Customer Contact Email,Zákazník Kontaktný e-mail
 DocType: Sales Team,Contribution (%),Příspěvek (%)
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +457,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Položka Platba nebude vytvořili, protože ""v hotovosti nebo bankovním účtu"" nebyl zadán"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +464,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Položka Platba nebude vytvořili, protože ""v hotovosti nebo bankovním účtu"" nebyl zadán"
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +171,Responsibilities,Zodpovednosť
 apps/erpnext/erpnext/stock/doctype/item/item_list.js +11,Template,Šablona
 DocType: Sales Person,Sales Person Name,Prodej Osoba Name
 apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Zadejte prosím aspoň 1 fakturu v tabulce
-apps/erpnext/erpnext/public/js/setup_wizard.js +270,Add Users,Pridať užívateľa
+apps/erpnext/erpnext/public/js/setup_wizard.js +273,Add Users,Pridať užívateľa
 DocType: Pricing Rule,Item Group,Položka Group
 DocType: Task,Actual Start Date (via Time Logs),Skutočný dátum Start (cez Time Záznamy)
 DocType: Stock Reconciliation Item,Before reconciliation,Pred zmierenie
 apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Chcete-li {0}
 DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Daně a poplatky Přidal (Company měna)
-apps/erpnext/erpnext/stock/doctype/item/item.py +344,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Položka Tax Row {0} musí mít účet typu daní či výnosů nebo nákladů, nebo Vyměřovací"
+apps/erpnext/erpnext/stock/doctype/item/item.py +374,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Položka Tax Row {0} musí mít účet typu daní či výnosů nebo nákladů, nebo Vyměřovací"
 DocType: Sales Order,Partly Billed,Částečně Účtovaný
 DocType: Item,Default BOM,Výchozí BOM
 apps/erpnext/erpnext/setup/doctype/company/company.js +22,Please re-type company name to confirm,Prosím re-typ názov spoločnosti na potvrdenie
@@ -2562,7 +2566,7 @@
 DocType: Time Log,From Time,Času od
 DocType: Notification Control,Custom Message,Custom Message
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +33,Investment Banking,Investiční bankovnictví
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +369,Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +370,Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního
 DocType: Purchase Invoice,Price List Exchange Rate,Katalogová cena Exchange Rate
 DocType: Purchase Invoice Item,Rate,Sadzba
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Intern,Internovat
@@ -2594,7 +2598,7 @@
 DocType: Purchase Invoice,Items,Položky
 DocType: Fiscal Year,Year Name,Meno roku
 DocType: Process Payroll,Process Payroll,Proces Payroll
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +73,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +77,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
 DocType: Product Bundle Item,Product Bundle Item,Product Bundle Item
 DocType: Sales Partner,Sales Partner Name,Sales Partner Name
 DocType: Purchase Invoice Item,Image View,Image View
@@ -2605,7 +2609,7 @@
 DocType: Delivery Note Item,From Warehouse,Zo skladu
 DocType: Purchase Taxes and Charges,Valuation and Total,Oceňování a Total
 DocType: Tax Rule,Shipping City,Prepravné City
-apps/erpnext/erpnext/stock/doctype/item/item.js +43,This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,"Tento bod je varianta {0} (šablony). Atributy budou zkopírovány z šablony, pokud je nastaveno ""No Copy"""
+apps/erpnext/erpnext/stock/doctype/item/item.js +58,This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,"Tento bod je varianta {0} (šablony). Atributy budou zkopírovány z šablony, pokud je nastaveno ""No Copy"""
 DocType: Account,Purchase User,Nákup Uživatel
 DocType: Notification Control,Customize the Notification,Přizpůsobit oznámení
 apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +24,Default Address Template cannot be deleted,Výchozí šablony adresy nemůže být smazán
@@ -2615,7 +2619,7 @@
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +54,Total cannot be zero,Celkem nemůže být nula
 apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +16,'Days Since Last Order' must be greater than or equal to zero,"""Dní od poslednej objednávky"" musí byť väčšie alebo rovnajúce sa nule"
 DocType: C-Form,Amended From,Platném znění
-apps/erpnext/erpnext/public/js/setup_wizard.js +374,Raw Material,Surovina
+apps/erpnext/erpnext/public/js/setup_wizard.js +377,Raw Material,Surovina
 DocType: Leave Application,Follow via Email,Sledovat e-mailem
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po slevě Částka
 apps/erpnext/erpnext/accounts/doctype/account/account.py +181,Child account exists for this account. You can not delete this account.,Dětské konto existuje pro tento účet. Nemůžete smazat tento účet.
@@ -2632,7 +2636,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/default_website.py +72,General,Všeobecný
 apps/erpnext/erpnext/public/js/setup_wizard.js +256,Attach Letterhead,Pripojiť Hlavičku
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +272,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, pokud kategorie je určena pro ""ocenění"" nebo ""oceňování a celkový"""
-apps/erpnext/erpnext/public/js/setup_wizard.js +299,"List your tax heads (e.g. VAT, Customs etc; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Vypíšte vaše používané dane (napr DPH, Clo atď; mali by mať jedinečné názvy) a ich štandardné sadzby. Týmto sa vytvorí štandardná šablóna, ktorú môžete upraviť a pridať ďalšie neskôr."
+apps/erpnext/erpnext/public/js/setup_wizard.js +302,"List your tax heads (e.g. VAT, Customs etc; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Vypíšte vaše používané dane (napr DPH, Clo atď; mali by mať jedinečné názvy) a ich štandardné sadzby. Týmto sa vytvorí štandardná šablóna, ktorú môžete upraviť a pridať ďalšie neskôr."
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +230,Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
 DocType: Journal Entry,Bank Entry,Bank Entry
 DocType: Authorization Rule,Applicable To (Designation),Vztahující se na (označení)
@@ -2643,9 +2647,9 @@
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,Entertainment & Leisure
 DocType: Purchase Order,The date on which recurring order will be stop,"Datum, ke kterému se opakující objednávka bude zastaví"
 DocType: Quality Inspection,Item Serial No,Položka Výrobní číslo
-apps/erpnext/erpnext/controllers/status_updater.py +142,{0} must be reduced by {1} or you should increase overflow tolerance,{0} musí byť znížený o {1} alebo by ste mali zvýšiť toleranciu presahu
+apps/erpnext/erpnext/controllers/status_updater.py +143,{0} must be reduced by {1} or you should increase overflow tolerance,{0} musí byť znížený o {1} alebo by ste mali zvýšiť toleranciu presahu
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +57,Total Present,Celkem Present
-apps/erpnext/erpnext/public/js/setup_wizard.js +378,Hour,Hodina
+apps/erpnext/erpnext/public/js/setup_wizard.js +381,Hour,Hodina
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +145,"Serialized Item {0} cannot be updated \
 					using Stock Reconciliation","Serialized Položka {0} nelze aktualizovat \
  pomocí Reklamní Odsouhlasení"
@@ -2653,7 +2657,7 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,"New Pořadové číslo nemůže mít Warehouse. Warehouse musí být nastaveny Stock vstupním nebo doklad o koupi,"
 DocType: Lead,Lead Type,Lead Type
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +82,Create Quotation,Vytvoriť Ponuku
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +109,You are not authorized to approve leaves on Block Dates,Nie ste oprávnení schvaľovať lístie na bloku Termíny
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +110,You are not authorized to approve leaves on Block Dates,Nie ste oprávnení schvaľovať lístie na bloku Termíny
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +311,All these items have already been invoiced,Všechny tyto položky již byly fakturovány
 apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Může být schválena {0}
 DocType: Shipping Rule,Shipping Rule Conditions,Přepravní Článek Podmínky
@@ -2666,7 +2670,6 @@
 DocType: Quality Inspection,Report Date,Datum Reportu
 DocType: C-Form,Invoices,Faktúry
 DocType: Job Opening,Job Title,Název pozice
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +54,{0} already allocated for Employee {1} for period {2} - {3},{0} už pridelené pre zamestnancov {1} na dobu {2} - {3}
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +80,{0} Recipients,{0} príjemcov
 DocType: Features Setup,Item Groups in Details,Položka skupiny v detailech
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +335,Quantity to Manufacture must be greater than 0.,"Množstvo, ktoré má výroba musí byť väčšia ako 0 ° C."
@@ -2684,7 +2687,7 @@
 apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Není nic upravovat.
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +108,Summary for this month and pending activities,Zhrnutie pre tento mesiac a prebiehajúcim činnostiam
 DocType: Customer Group,Customer Group Name,Zákazník Group Name
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +410,Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +411,Please remove this Invoice {0} from C-Form {1},Odeberte Tato faktura {0} z C-Form {1}
 DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,"Prosím, vyberte převádět pokud chcete také zahrnout uplynulý fiskální rok bilance listy tohoto fiskálního roku"
 DocType: GL Entry,Against Voucher Type,Proti poukazu typu
 DocType: Item,Attributes,Atribúty
@@ -2752,7 +2755,7 @@
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +53,Above,Vyššie
 DocType: Salary Slip,Earning & Deduction,Výdělek a dedukce
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +76,Account {0} cannot be a Group,Účet {0} nemůže být skupina
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +216,Optional. This setting will be used to filter in various transactions.,Volitelné. Toto nastavení bude použito k filtrování v různých transakcí.
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +219,Optional. This setting will be used to filter in various transactions.,Volitelné. Toto nastavení bude použito k filtrování v různých transakcí.
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +111,Negative Valuation Rate is not allowed,Negativní ocenění Rate není povoleno
 DocType: Holiday List,Weekly Off,Týdenní Off
 DocType: Fiscal Year,"For e.g. 2012, 2012-13","Pro např 2012, 2012-13"
@@ -2818,7 +2821,7 @@
 apps/erpnext/erpnext/setup/doctype/company/company.js +38,Successfully deleted all transactions related to this company!,Úspešne vypúšťa všetky transakcie súvisiace s týmto spoločnosti!
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Rovnako ako u Date
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +58,Probation,Zkouška
-apps/erpnext/erpnext/stock/doctype/item/item.py +268,Default Warehouse is mandatory for stock Item.,Výchozí Sklad je povinný pro živočišnou položky.
+apps/erpnext/erpnext/stock/doctype/item/item.py +298,Default Warehouse is mandatory for stock Item.,Výchozí Sklad je povinný pro živočišnou položky.
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +173,Payment of salary for the month {0} and year {1},Platba platu za měsíc {0} a rok {1}
 DocType: Stock Settings,Auto insert Price List rate if missing,"Auto vložka Cenník miera, ak chýba"
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Paid Amount,Celkem uhrazené částky
@@ -2828,7 +2831,7 @@
 apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +9,Make Time Log Batch,Udělejte si čas Log Batch
 apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Issued,Vydané
 DocType: Project,Total Billing Amount (via Time Logs),Celkom Billing Suma (cez Time Záznamy)
-apps/erpnext/erpnext/public/js/setup_wizard.js +380,We sell this Item,Táto položka je na predaj
+apps/erpnext/erpnext/public/js/setup_wizard.js +383,We sell this Item,Táto položka je na predaj
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +65,Supplier Id,Dodavatel Id
 DocType: Journal Entry,Cash Entry,Cash Entry
 DocType: Sales Partner,Contact Desc,Kontakt Popis
@@ -2882,7 +2885,7 @@
 DocType: Purchase Order Item,Supplier Quotation,Dodávateľská ponuka
 DocType: Quotation,In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku."
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,{0} {1} is stopped,{0} {1} je zastavený
-apps/erpnext/erpnext/stock/doctype/item/item.py +356,Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +386,Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
 DocType: Lead,Add to calendar on this date,Přidat do kalendáře k tomuto datu
 apps/erpnext/erpnext/config/selling.py +132,Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +40,Upcoming Events,Pripravované akcie
@@ -2890,7 +2893,7 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +27,Quick Entry,Rýchly vstup
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} je povinné pre návrat
 DocType: Purchase Order,To Receive,Obdržať
-apps/erpnext/erpnext/public/js/setup_wizard.js +281,user@example.com,user@example.com
+apps/erpnext/erpnext/public/js/setup_wizard.js +284,user@example.com,user@example.com
 DocType: Email Digest,Income / Expense,Výnosy / náklady
 DocType: Employee,Personal Email,Osobní e-mail
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +62,Total Variance,Celkový rozptyl
@@ -2903,7 +2906,7 @@
 DocType: Customer,From Lead,Od Obchodnej iniciatívy
 apps/erpnext/erpnext/config/manufacturing.py +19,Orders released for production.,Objednávky uvolněna pro výrobu.
 apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +42,Select Fiscal Year...,Vyberte fiskálního roku ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444,POS Profile required to make POS Entry,"POS Profile požadované, aby POS Vstup"
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +451,POS Profile required to make POS Entry,"POS Profile požadované, aby POS Vstup"
 DocType: Hub Settings,Name Token,Jméno Token
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +113,Standard Selling,Standardní prodejní
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +137,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
@@ -2953,7 +2956,7 @@
 DocType: Employee,Held On,Které se konalo dne
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +33,Production Item,Výrobní položka
 ,Employee Information,Informace o zaměstnanci
-apps/erpnext/erpnext/public/js/setup_wizard.js +309,Rate (%),Sadzba (%)
+apps/erpnext/erpnext/public/js/setup_wizard.js +312,Rate (%),Sadzba (%)
 DocType: Stock Entry Detail,Additional Cost,Dodatočné náklady
 apps/erpnext/erpnext/public/js/setup_wizard.js +155,Financial Year End Date,Finanční rok Datum ukončení
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Voucher No, if grouped by Voucher","Nelze filtrovat na základě poukazu ne, pokud seskupeny podle poukazu"
@@ -2961,7 +2964,7 @@
 DocType: Quality Inspection,Incoming,Přicházející
 DocType: BOM,Materials Required (Exploded),Potřebný materiál (Rozložený)
 DocType: Salary Structure Earning,Reduce Earning for Leave Without Pay (LWP),Snížit Zisk na vstup bez nároku na mzdu (LWP)
-apps/erpnext/erpnext/public/js/setup_wizard.js +271,"Add users to your organization, other than yourself","Pridanie používateľov do vašej organizácie, iné ako vy"
+apps/erpnext/erpnext/public/js/setup_wizard.js +274,"Add users to your organization, other than yourself","Pridanie používateľov do vašej organizácie, iné ako vy"
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97,Row # {0}: Serial No {1} does not match with {2} {3},Riadok # {0}: Výrobné číslo {1} nezodpovedá {2} {3}
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +44,Casual Leave,Casual Leave
 DocType: Batch,Batch ID,Šarže ID
@@ -2999,7 +3002,7 @@
 DocType: Purchase Order,End date of current order's period,Datum ukončení doby aktuální objednávky
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +17,Make Offer Letter,Vytvorte ponuku Letter
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +10,Return,Spiatočná
-apps/erpnext/erpnext/stock/doctype/item/item.py +514,Default Unit of Measure for Variant must be same as Template,Východzí merná jednotka varianty musia byť rovnaké ako šablónu
+apps/erpnext/erpnext/stock/doctype/item/item.py +544,Default Unit of Measure for Variant must be same as Template,Východzí merná jednotka varianty musia byť rovnaké ako šablónu
 DocType: Production Order Operation,Production Order Operation,Výrobní zakázka Operace
 DocType: Pricing Rule,Disable,Zakázat
 DocType: Project Task,Pending Review,Čeká Review
@@ -3007,7 +3010,7 @@
 apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py +66,Customer Id,Zákazník Id
 apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +110,To Time must be greater than From Time,Ak chcete čas musí byť väčší ako From Time
 DocType: Journal Entry Account,Exchange Rate,Výmenný kurz
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467,Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +474,Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0}: Parent account {1} does not bolong to the company {2},Sklad {0}: Nadřazený účet {1} napatří společnosti {2}
 DocType: BOM,Last Purchase Rate,Last Cena při platbě
 DocType: Account,Asset,Majetek
@@ -3044,7 +3047,7 @@
 DocType: Opportunity,Next Contact,Nasledujúce Kontakt
 DocType: Employee,Employment Type,Typ zaměstnání
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +40,Fixed Assets,Dlouhodobý majetek
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +84,Application period cannot be across two alocation records,Obdobie podávania žiadostí nemôže byť na dvoch alokácie záznamy
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +85,Application period cannot be across two alocation records,Obdobie podávania žiadostí nemôže byť na dvoch alokácie záznamy
 DocType: Item Group,Default Expense Account,Výchozí výdajového účtu
 DocType: Employee,Notice (days),Oznámení (dny)
 DocType: Tax Rule,Sales Tax Template,Daň z predaja Template
@@ -3085,7 +3088,6 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +91,Project Manager,Project Manager
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +72,Dispatch,Odeslání
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +70,Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
-DocType: Customer,Default Taxes and Charges,Východiskové Dane a poplatky
 DocType: Account,Receivable,Pohledávky
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +263,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Riadok # {0}: Nie je povolené meniť dodávateľa, objednávky už existuje"
 DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Role, která se nechá podat transakcí, které přesahují úvěrové limity."
@@ -3120,11 +3122,11 @@
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +46,Please enter Purchase Receipts,"Prosím, zadejte Nákup Příjmy"
 DocType: Sales Invoice,Get Advances Received,Získat přijaté zálohy
 DocType: Email Digest,Add/Remove Recipients,Přidat / Odebrat příjemce
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +427,Transaction not allowed against stopped Production Order {0},Transakce není povoleno proti zastavila výrobu Objednat {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +425,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/config/support.py +54,Setup incoming server for support email id. (e.g. support@example.com),Nastavenie serveru prichádzajúcej pošty pre email podpory. (Napríklad podpora@priklad.com)
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +19,Shortage Qty,Nedostatek Množství
-apps/erpnext/erpnext/stock/doctype/item/item.py +539,Item variant {0} exists with same attributes,Variant Položky {0} existuje s rovnakými vlastnosťami
+apps/erpnext/erpnext/stock/doctype/item/item.py +569,Item variant {0} exists with same attributes,Variant Položky {0} existuje s rovnakými vlastnosťami
 DocType: Salary Slip,Salary Slip,Plat Slip
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +48,'To Date' is required,"""Datum Do"" je povinný"
 DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generování balení pásky pro obaly mají být dodány. Používá se k oznámit číslo balíku, obsah balení a jeho hmotnost."
@@ -3244,18 +3246,18 @@
 DocType: Workstation,Operating Costs,Provozní náklady
 DocType: Employee Leave Approver,Employee Leave Approver,Zaměstnanec Leave schvalovač
 apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +166,{0} has been successfully added to our Newsletter list.,{0} bol úspešne pridaný do nášho zoznamu noviniek.
-apps/erpnext/erpnext/stock/doctype/item/item.py +394,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: Položka Změna pořadí již pro tento sklad existuje {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +424,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 +67,"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
 DocType: Purchase Taxes and Charges Template,Purchase Master Manager,Nákup Hlavní manažer
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +424,Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +422,Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy
 apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +150,Please select Start Date and End Date for Item {0},"Prosím, vyberte Počáteční datum a koncové datum pro položku {0}"
 apps/erpnext/erpnext/config/stock.py +136,Main Reports,Hlavné správy
 apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,K dnešnímu dni nemůže být dříve od data
 DocType: Purchase Receipt Item,Prevdoc DocType,Prevdoc DOCTYPE
-apps/erpnext/erpnext/stock/doctype/item/item.js +178,Add / Edit Prices,Přidat / Upravit ceny
+apps/erpnext/erpnext/stock/doctype/item/item.js +193,Add / Edit Prices,Přidat / Upravit ceny
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +53,Chart of Cost Centers,Diagram nákladových středisek
 ,Requested Items To Be Ordered,Požadované položky je třeba objednat
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +293,My Orders,Moje objednávky
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +295,My Orders,Moje objednávky
 DocType: Price List,Price List Name,Ceník Jméno
 DocType: Time Log,For Manufacturing,Pre výrobu
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +174,Totals,Súčty
@@ -3263,8 +3265,8 @@
 ,Ordered Items To Be Delivered,"Objednané zboží, které mají být dodány"
 DocType: Account,Income,Příjem
 DocType: Industry Type,Industry Type,Typ Průmyslu
-apps/erpnext/erpnext/templates/includes/cart.js +137,Something went wrong!,Něco se pokazilo!
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +100,Warning: Leave application contains following block dates,Upozornění: Nechte Aplikace obsahuje následující data bloku
+apps/erpnext/erpnext/templates/includes/cart.js +136,Something went wrong!,Něco se pokazilo!
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +101,Warning: Leave application contains following block dates,Upozornění: Nechte Aplikace obsahuje následující data bloku
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +256,Sales Invoice {0} has already been submitted,Prodejní faktury {0} již byla odeslána
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Dokončení Datum
 DocType: Purchase Invoice Item,Amount (Company Currency),Částka (Měna Společnosti)
@@ -3287,9 +3289,9 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +265,You cannot credit and debit same account at the same time,Nemůžete dělat kreditní a debetní záznam na stejný účet ve stejnou dobu.
 DocType: Naming Series,Help HTML,Nápověda HTML
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +50,Total weightage assigned should be 100%. It is {0},Celková weightage přiřazen by měla být 100%. Je {0}
-apps/erpnext/erpnext/controllers/status_updater.py +140,Allowance for over-{0} crossed for Item {1},Příspěvek na nadměrné {0} přešel k bodu {1}
+apps/erpnext/erpnext/controllers/status_updater.py +141,Allowance for over-{0} crossed for Item {1},Příspěvek na nadměrné {0} přešel k bodu {1}
 DocType: Address,Name of person or organization that this address belongs to.,"Meno osoby alebo organizácie, ktorej patrí táto adresa."
-apps/erpnext/erpnext/public/js/setup_wizard.js +340,Your Suppliers,Vaši Dodávatelia
+apps/erpnext/erpnext/public/js/setup_wizard.js +343,Your Suppliers,Vaši Dodávatelia
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +58,Cannot set as Lost as Sales Order is made.,"Nelze nastavit jako Ztraceno, protože je přijata objednávka."
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +65,Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,"Další platovou strukturu {0} je aktivní pro zaměstnance {1}. Prosím, aby jeho stav ""neaktivní"" pokračovat."
 DocType: Purchase Invoice,Contact,Kontakt
@@ -3300,6 +3302,7 @@
 DocType: Employee,Date of Issue,Datum vydání
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +16,{0}: From {0} for {1},{0}: Od {0} do {1}
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +149,Row #{0}: Set Supplier for item {1},Riadok # {0}: Nastavte Dodávateľ pre položku {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +105,Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} pripája k bodu {1} nemožno nájsť
 DocType: Issue,Content Type,Typ obsahu
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,Počítač
 DocType: Item,List this Item in multiple groups on the website.,Seznam tuto položku ve více skupinách na internetových stránkách.
@@ -3313,7 +3316,7 @@
 DocType: Delivery Note,To Warehouse,Do skladu
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +45,Account {0} has been entered more than once for fiscal year {1},Účet {0} byl zadán více než jednou za fiskální rok {1}
 ,Average Commission Rate,Průměrná cena Komise
-apps/erpnext/erpnext/stock/doctype/item/item.py +317,'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemôže byť ""áno"" pre neskladový tovar"
+apps/erpnext/erpnext/stock/doctype/item/item.py +347,'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemôže byť ""áno"" pre neskladový tovar"
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +34,Attendance can not be marked for future dates,Účast nemůže být označen pro budoucí data
 DocType: Pricing Rule,Pricing Rule Help,Ceny Pravidlo Help
 DocType: Purchase Taxes and Charges,Account Head,Účet Head
@@ -3327,7 +3330,7 @@
 DocType: Item,Customer Code,Code zákazníků
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +212,Birthday Reminder for {0},Narozeninová připomínka pro {0}
 apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +72,Days Since Last Order,Počet dnů od poslední objednávky
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +299,Debit To account must be a Balance Sheet account,Debetné Na účet musí byť účtu Súvaha
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +300,Debit To account must be a Balance Sheet account,Debetné Na účet musí byť účtu Súvaha
 DocType: Buying Settings,Naming Series,Číselné řady
 DocType: Leave Block List,Leave Block List Name,Nechte Jméno Block List
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Stock Aktiva
@@ -3340,7 +3343,7 @@
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Záverečný účet {0} musí byť typu zodpovednosti / Equity
 DocType: Authorization Rule,Based On,Založeno na
 DocType: Sales Order Item,Ordered Qty,Objednáno Množství
-apps/erpnext/erpnext/stock/doctype/item/item.py +550,Item {0} is disabled,Položka {0} je zakázaná
+apps/erpnext/erpnext/stock/doctype/item/item.py +580,Item {0} is disabled,Položka {0} je zakázaná
 DocType: Stock Settings,Stock Frozen Upto,Reklamní Frozen aľ
 apps/erpnext/erpnext/controllers/recurring_document.py +163,Period From and Period To dates mandatory for recurring {0},"Obdobie od a obdobia, k dátam povinné pre opakované {0}"
 apps/erpnext/erpnext/config/projects.py +13,Project activity / task.,Projektová činnost / úkol.
@@ -3348,7 +3351,7 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Buying must be checked, if Applicable For is selected as {0}","Nákup musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Sleva musí být menší než 100
 DocType: Purchase Invoice,Write Off Amount (Company Currency),Odpísať Suma (Company meny)
-apps/erpnext/erpnext/stock/doctype/item/item.py +385,Row #{0}: Please set reorder quantity,Riadok # {0}: Prosím nastavte množstvo objednávacie
+apps/erpnext/erpnext/stock/doctype/item/item.py +415,Row #{0}: Please set reorder quantity,Riadok # {0}: Prosím nastavte množstvo objednávacie
 DocType: Landed Cost Voucher,Landed Cost Voucher,Přistálo Náklady Voucher
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +55,Please set {0},Prosím nastavte {0}
 DocType: Purchase Invoice,Repeat on Day of Month,Opakujte na den v měsíci
@@ -3372,14 +3375,13 @@
 DocType: Purchase Receipt Item,Rejected Serial No,Zamítnuto Serial No
 apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +40,New Newsletter,New Newsletter
 apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +157,Start date should be less than end date for Item {0},Datum zahájení by měla být menší než konečné datum pro bod {0}
-apps/erpnext/erpnext/stock/doctype/item/item.js +17,Show Balance,Show Balance
 DocType: Item,"Example: ABCD.#####
 If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Příklad:. ABCD ##### 
  Je-li série nastavuje a pořadové číslo není uvedeno v transakcích, bude vytvořen poté automaticky sériové číslo na základě této série. Pokud chcete vždy výslovně uvést pořadová čísla pro tuto položku. ponechte prázdné."
 DocType: Upload Attendance,Upload Attendance,Nahrát Návštěvnost
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +119,BOM and Manufacturing Quantity are required,BOM a výroba množstva sú povinné
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Stárnutí rozsah 2
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +450,Amount,Částka
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +446,Amount,Částka
 apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +21,BOM replaced,BOM nahradil
 ,Sales Analytics,Prodejní Analytics
 DocType: Manufacturing Settings,Manufacturing Settings,Nastavenia Výroby
@@ -3388,7 +3390,7 @@
 DocType: Stock Entry Detail,Stock Entry Detail,Reklamní Entry Detail
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +101,Daily Reminders,Denná Upomienky
 apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +82,Tax Rule Conflicts with {0},Daňové Pravidlo Konflikty s {0}
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +207,New Account Name,Nový název účtu
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +210,New Account Name,Nový název účtu
 DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Dodává se nákladů na suroviny
 DocType: Selling Settings,Settings for Selling Module,Nastavenie modulu Predaj
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +73,Customer Service,Služby zákazníkům
@@ -3410,7 +3412,7 @@
 DocType: Sales Order Item,Produced Quantity,Produkoval Množství
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Engineer,Inženýr
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Vyhľadávanie Sub Assemblies
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +379,Item Code required at Row No {0},Kód položky třeba na řádku č {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +380,Item Code required at Row No {0},Kód položky třeba na řádku č {0}
 DocType: Sales Partner,Partner Type,Partner Type
 DocType: Purchase Taxes and Charges,Actual,Aktuální
 DocType: Authorization Rule,Customerwise Discount,Sleva podle zákazníka
@@ -3444,7 +3446,7 @@
 DocType: Attendance,Attendance,Účast
 DocType: BOM,Materials,Materiály
 DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Pokud není zatrženo, seznam bude muset být přidány ke každé oddělení, kde má být použit."
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +520,Posting date and posting time is mandatory,Datum a čas zadání je povinný
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +518,Posting date and posting time is mandatory,Datum a čas zadání je povinný
 apps/erpnext/erpnext/config/buying.py +79,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."
@@ -3471,13 +3473,13 @@
 DocType: Packing Slip,Gross Weight UOM,Hrubá Hmotnosť MJ
 DocType: Email Digest,Receivables / Payables,Pohledávky / Závazky
 DocType: Delivery Note Item,Against Sales Invoice,Proti prodejní faktuře
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +457,Credit Account,Úverový účet
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +453,Credit Account,Úverový účet
 DocType: Landed Cost Item,Landed Cost Item,Přistálo nákladovou položkou
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +56,Show zero values,Ukázat nulové hodnoty
 DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Množství položky získané po výrobě / přebalení z daných množství surovin
 DocType: Payment Reconciliation,Receivable / Payable Account,Pohledávky / závazky účet
 DocType: Delivery Note Item,Against Sales Order Item,Proti položce přijaté objednávky
-apps/erpnext/erpnext/stock/doctype/item/item.py +532,Please specify Attribute Value for attribute {0},Uveďte atribútu Hodnota atribútu {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +562,Please specify Attribute Value for attribute {0},Uveďte atribútu Hodnota atribútu {0}
 DocType: Item,Default Warehouse,Výchozí Warehouse
 DocType: Task,Actual End Date (via Time Logs),Skutočné Dátum ukončenia (cez Time Záznamy)
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +37,Budget cannot be assigned against Group Account {0},Rozpočet nemôže byť priradená na skupinový účet {0}
@@ -3487,7 +3489,7 @@
 DocType: Issue,Support Team,Tým podpory
 DocType: Appraisal,Total Score (Out of 5),Celkové skóre (Out of 5)
 DocType: Batch,Batch,Šarže
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +28,Balance,Zůstatek
+apps/erpnext/erpnext/stock/doctype/item/item.js +20,Balance,Zůstatek
 DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nárokov)
 DocType: Journal Entry,Debit Note,Debit Note
 DocType: Stock Entry,As per Stock UOM,Podľa skladovej MJ
@@ -3515,10 +3517,10 @@
 ,Items To Be Requested,Položky se budou vyžadovat
 DocType: Time Log,Billing Rate based on Activity Type (per hour),Účtovaná sadzba založená na typ aktivity (za hodinu)
 DocType: Company,Company Info,Informácie o spoločnosti
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +211,"Company Email ID not found, hence mail not sent","Společnost E-mail ID nebyl nalezen, proto pošta neodeslána"
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +218,"Company Email ID not found, hence mail not sent","Společnost E-mail ID nebyl nalezen, proto pošta neodeslána"
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Aplikace fondů (aktiv)
 DocType: Production Planning Tool,Filter based on item,Filtr dle položek
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +451,Debit Account,Debetné účet
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +447,Debit Account,Debetné účet
 DocType: Fiscal Year,Year Start Date,Dátom začiatku roka
 DocType: Attendance,Employee Name,Jméno zaměstnance
 DocType: Sales Invoice,Rounded Total (Company Currency),Zaoblený Total (Company Měna)
@@ -3546,17 +3548,17 @@
 apps/erpnext/erpnext/public/js/pos/pos.js +91,Price List not found or disabled,Ceník nebyl nalezen nebo zakázán
 DocType: Expense Claim,Approved,Schválený
 DocType: Pricing Rule,Price,Cena
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +93,Employee relieved on {0} must be set as 'Left',"Zaměstnanec úlevu na {0} musí být nastaven jako ""Left"""
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +99,Employee relieved on {0} must be set as 'Left',"Zaměstnanec úlevu na {0} musí být nastaven jako ""Left"""
 DocType: Item,"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","Výběrem ""Yes"" dá jedinečnou identitu každého subjektu této položky, které lze zobrazit v sériové číslo mistra."
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +39,Appraisal {0} created for Employee {1} in the given date range,Posouzení {0} vytvořil pro zaměstnance {1} v daném časovém období
 DocType: Employee,Education,Vzdělání
 DocType: Selling Settings,Campaign Naming By,Kampaň Pojmenování By
 DocType: Employee,Current Address Is,Aktuální adresa je
-apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +220,"Optional. Sets company's default currency, if not specified.","Voliteľné. Nastaví východiskovej mene spoločnosti, ak nie je uvedené."
+apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +223,"Optional. Sets company's default currency, if not specified.","Voliteľné. Nastaví východiskovej mene spoločnosti, ak nie je uvedené."
 DocType: Address,Office,Kancelář
 apps/erpnext/erpnext/config/accounts.py +13,Accounting journal entries.,Zápisy v účetním deníku.
 DocType: Delivery Note Item,Available Qty at From Warehouse,K dispozícii Množstvo na Od Warehouse
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Please select Employee Record first.,"Prosím, vyberte zamestnanca záznam prvý."
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +226,Please select Employee Record first.,"Prosím, vyberte zamestnanca záznam prvý."
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +185,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Riadok {0}: Party / Account nezhoduje s {1} / {2} do {3} {4}
 apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +35,To create a Tax Account,Chcete-li vytvořit daňovém účtu
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,"Prosím, zadejte výdajového účtu"
@@ -3576,7 +3578,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 +93,Total Tax,Total Tax
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +178,For Quantity (Manufactured Qty) is mandatory,Pre Množstvo (Vyrobené ks) je povinné
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +176,For Quantity (Manufactured Qty) is mandatory,Pre Množstvo (Vyrobené ks) je povinné
 DocType: Stock Entry,Default Target Warehouse,Výchozí Target Warehouse
 DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Company Měna)
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +79,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Riadok {0}: Typ Party Party a je použiteľná len proti pohľadávky / záväzky účtu
@@ -3600,7 +3602,7 @@
 apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +46,Total Unpaid,Celkom Neplatené
 apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +21,Time Log is not billable,Time Log není zúčtovatelné
 apps/erpnext/erpnext/stock/get_item_details.py +128,"Item {0} is a template, please select one of its variants","Položka {0} je šablóna, prosím vyberte jednu z jeho variantov"
-apps/erpnext/erpnext/public/js/setup_wizard.js +287,Purchaser,Kupec
+apps/erpnext/erpnext/public/js/setup_wizard.js +290,Purchaser,Kupec
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +81,Net pay cannot be negative,Net plat nemůže být záporný
 apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +107,Please enter the Against Vouchers manually,Zadejte prosím podle dokladů ručně
 DocType: SMS Settings,Static Parameters,Statické parametry
@@ -3626,9 +3628,9 @@
 DocType: Stock Entry,Repack,Přebalit
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Musíte Uložte formulář před pokračováním
 DocType: Item Attribute,Numeric Values,Číselné hodnoty
-apps/erpnext/erpnext/public/js/setup_wizard.js +261,Attach Logo,Pripojiť Logo
+apps/erpnext/erpnext/public/js/setup_wizard.js +262,Attach Logo,Pripojiť Logo
 DocType: Customer,Commission Rate,Výše provize
-apps/erpnext/erpnext/stock/doctype/item/item.js +38,Make Variant,Vytvoriť Variant
+apps/erpnext/erpnext/stock/doctype/item/item.js +53,Make Variant,Vytvoriť Variant
 apps/erpnext/erpnext/config/hr.py +145,Block leave applications by department.,Aplikace Block dovolené podle oddělení.
 apps/erpnext/erpnext/templates/pages/cart.html +42,Cart is Empty,Košík je prázdny
 DocType: Production Order,Actual Operating Cost,Skutečné provozní náklady
@@ -3647,12 +3649,12 @@
 DocType: Item,Automatically create Material Request if quantity falls below this level,"Automatické vytvorenie Materiál žiadosti, pokiaľ množstvo klesne pod túto úroveň"
 ,Item-wise Purchase Register,Item-moudrý Nákup Register
 DocType: Batch,Expiry Date,Datum vypršení platnosti
-apps/erpnext/erpnext/stock/doctype/item/item.py +379,"To set reorder level, item must be a Purchase Item or Manufacturing Item","Ak chcete nastaviť úroveň objednávacie, položka musí byť Nákup položka alebo výrobné položky"
+apps/erpnext/erpnext/stock/doctype/item/item.py +409,"To set reorder level, item must be a Purchase Item or Manufacturing Item","Ak chcete nastaviť úroveň objednávacie, položka musí byť Nákup položka alebo výrobné položky"
 ,Supplier Addresses and Contacts,Dodavatel Adresy a kontakty
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +268,Please select Category first,Nejdřív vyberte kategorii
 apps/erpnext/erpnext/config/projects.py +18,Project master.,Master Project.
 DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Neukazovať žiadny symbol ako $ atď vedľa meny.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +374, (Half Day),(Pol dňa)
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +380, (Half Day),(Pol dňa)
 DocType: Supplier,Credit Days,Úvěrové dny
 DocType: Leave Type,Is Carry Forward,Je převádět
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +565,Get Items from BOM,Získat předměty z BOM
