DocType: Employee,Salary Mode,Mode Plat
DocType: Cost Center,"Select Monthly Distribution, if you want to track based on seasonality.","Vyberte měsíční výplatou, pokud chcete sledovat na základě sezónnosti."
DocType: Employee,Divorced,Rozvedený
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +54,Warning: Same item has been entered multiple times.,Upozornění: Stejné položky byl zadán vícekrát.
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +96,Items already synced,Položky již synchronizovat
DocType: Purchase Order,"If you have created a standard template in Purchase Taxes and Charges Template, select one and click on the button below.","Pokud jste vytvořili standardní šablonu nákupem daní a poplatků šablony, vyberte jednu a klikněte na tlačítko níže."
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Materiál Navštivte {0} před zrušením této záruční reklamaci Zrušit
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +18,Consumer Products,Spotřební zboží
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +72,Please select Party Type first,"Prosím, vyberte typ Party první"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +89,Annealing,Žíhání
DocType: Item,Customer Items,Zákazník položky
apps/erpnext/erpnext/accounts/doctype/account/account.py +41,Account {0}: Parent account {1} can not be a ledger,Účet {0}: Nadřazený účet {1} nemůže být hlavní kniha
DocType: Item,Publish Item to hub.erpnext.com,Publikování položku do hub.erpnext.com
apps/erpnext/erpnext/config/setup.py +63,Email Notifications,E-mailová upozornění
DocType: Item,Default Unit of Measure,Výchozí Měrná jednotka
DocType: SMS Center,All Sales Partner Contact,Všechny Partneři Kontakt
DocType: Employee,Leave Approvers,Nechte schvalovatelů
DocType: Sales Partner,Dealer,Dealer
DocType: Employee,Rented,Pronajato
DocType: Stock Entry,Get Stock and Rate,Získejte skladem a Rate
DocType: About Us Settings,Website,Stránky
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +22,Compaction plus sintering,Zhutňování a spékání
DocType: Sales BOM,"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""","Položka, která představuje balíček. Tato položka musí mít ""je skladem"" jako ""No"" a ""Je Sales Item"" jako ""Yes"""
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +99,Currency is required for Price List {0},Měna je vyžadováno pro Ceníku {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bude se vypočítá v transakci.
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +125,Please enter Employee Id of this sales parson,"Prosím, zadejte ID zaměstnance této kupní farář"
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_googledrive.py +120,Please set Google Drive access keys in {0},Prosím nastavte klíče pro přístup Google Drive In {0}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +542,From Material Request,Z materiálu Poptávka
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +39,{0} Tree,{0} Strom
DocType: Job Applicant,Job Applicant,Job Žadatel
apps/erpnext/erpnext/hub_node/page/hub/hub_body.html +18,No more results.,Žádné další výsledky.
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +73,Legal,Právní
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +114,Actual type tax cannot be included in Item rate in row {0},Aktuální typ daň nemůže být zahrnutý v ceně Položka v řádku {0}
DocType: C-Form,Customer,Zákazník
DocType: Purchase Receipt Item,Required By,Vyžadováno
DocType: Department,Department,Oddělení
DocType: Purchase Order,% Billed,% Fakturováno
DocType: Selling Settings,Customer Name,Jméno zákazníka
DocType: Features Setup,"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Všech oblastech souvisejících vývozní jako měnu, přepočítacího koeficientu, export celkem, export celkovém součtu etc jsou k dispozici v dodací list, POS, citace, prodejní faktury, prodejní objednávky atd"
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Heads (nebo skupiny), proti nimž účetní zápisy jsou vyrobeny a stav je veden."
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +143,Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1})
DocType: Manufacturing Settings,Default 10 mins,Výchozí 10 min
DocType: Leave Type,Leave Type Name,Nechte Typ Jméno
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +143,Series Updated Successfully,Řada Aktualizováno Úspěšně
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +149,Stitching,Šití
DocType: Pricing Rule,Apply On,Naneste na
DocType: Item Price,Multiple Item prices.,Více ceny položku.
,Purchase Order Items To Be Received,Položky vydané objednávky k přijetí
DocType: SMS Center,All Supplier Contact,Vše Dodavatel Kontakt
DocType: Quality Inspection Reading,Parameter,Parametr
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +52,Please specify a Price List which is valid for Territory,"Uveďte prosím ceníku, který je platný pro území"
apps/erpnext/erpnext/projects/doctype/project/project.py +35,Expected End Date can not be less than Expected Start Date,"Očekávané Datum ukončení nemůže být nižší, než se očekávalo data zahájení"
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +235,Do really want to unstop production order:,Opravdu chcete uvolnit výrobní zakázky: 
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +190,New Leave Application,New Leave Application
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +129,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 +60,Show Variants,Zobrazit Varianty
DocType: Sales Invoice Item,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
DocType: Designation,Designation,Označení
DocType: Production Plan Item,Production Plan Item,Výrobní program Item
apps/erpnext/erpnext/hr/doctype/employee/employee.py +137,User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +30,Health Care,Péče o zdraví
DocType: Purchase Invoice,Monthly,Měsíčně
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +66,Invoice,Faktura
DocType: Maintenance Schedule Item,Periodicity,Periodicita
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +355,Email Address,E-mailová adresa
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +20,Defense,Obrana
DocType: Company,Abbr,Zkr
DocType: Appraisal Goal,Score (0-5),Score (0-5)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +205,Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} se neshoduje s {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +62,Row # {0}:,Řádek # {0}:
DocType: Delivery Note,Vehicle No,Vozidle
sites/assets/js/erpnext.min.js +50,Please select Price List,"Prosím, vyberte Ceník"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +161,Woodworking,Zpracování dřeva
DocType: Production Order Operation,Work In Progress,Work in Progress
DocType: Company,If Monthly Budget Exceeded,Pokud Měsíční rozpočet překročen
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +152,3D printing,3D tisk
DocType: Employee,Holiday List,Dovolená Seznam
DocType: Time Log,Time Log,Time Log
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +80,Accountant,Účetní
DocType: Company,Phone No,Telefon
DocType: Time Log,"Log of Activities performed by users against Tasks that can be used for tracking time, billing.","Log činností vykonávaných uživateli proti úkoly, které mohou být použity pro sledování času, fakturaci."
apps/erpnext/erpnext/controllers/recurring_document.py +125,New {0}: #{1},Nový {0}: # {1}
,Sales Partners Commission,Obchodní partneři Komise
apps/erpnext/erpnext/setup/doctype/company/company.py +31,Abbreviation cannot have more than 5 characters,Zkratka nesmí mít více než 5 znaků
DocType: Backup Manager,Allow Google Drive Access,Povolit Google disku přístup
DocType: Email Digest,Projects & System,Projekty a System
DocType: Print Settings,Classic,Klasické
apps/erpnext/erpnext/accounts/doctype/account/account.js +27,This is a root account and cannot be edited.,To je kořen účtu a nelze upravovat.
DocType: Shopping Cart Settings,Shipping Rules,Přepravní řád
DocType: BOM,Operations,Operace
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Nelze nastavit oprávnění na základě Sleva pro {0}
DocType: 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","Připojit CSV soubor se dvěma sloupci, jeden pro starý název a jeden pro nový název"
DocType: Packed Item,Parent Detail docname,Parent Detail docname
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Kg,Kg
apps/erpnext/erpnext/config/hr.py +48,Opening for a Job.,Otevření o zaměstnání.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +5,Advertising,Reklama
DocType: Employee,Married,Ženatý
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +339,Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
DocType: Payment Reconciliation,Reconcile,Srovnat
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +29,Grocery,Potraviny
DocType: Quality Inspection Reading,Reading 1,Čtení 1
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +93,Make Bank Entry,Proveďte Bank Vstup
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +39,Pension Funds,Penzijní fondy
apps/erpnext/erpnext/accounts/doctype/account/account.py +116,Warehouse is mandatory if account type is Warehouse,"Sklad je povinné, pokud typ účtu je Warehouse"
DocType: SMS Center,All Sales Person,Všichni obchodní zástupci
DocType: Backup Manager,Credentials,Pověřovací listiny
DocType: Purchase Order,"Check if recurring order, uncheck to stop recurring or put proper End Date","Zkontrolujte, zda je opakující se, zrušte zaškrtnutí políčka zastavit opakované nebo dát správné datum ukončení"
DocType: Sales Invoice Item,Sales Invoice Item,Prodejní faktuře položka
DocType: Account,Credit,Úvěr
apps/erpnext/erpnext/hr/doctype/employee/employee.py +25,Please setup Employee Naming System in Human Resource > HR Settings,"Prosím, setup zaměstnanců pojmenování systému v oblasti lidských zdrojů> Nastavení HR"
DocType: POS Setting,Write Off Cost Center,Odepsat nákladové středisko
DocType: Warehouse,Warehouse Detail,Sklad Detail
apps/erpnext/erpnext/selling/doctype/customer/customer.py +159,Credit limit has been crossed for customer {0} {1}/{2},Úvěrový limit byla překročena o zákazníka {0} {1} / {2}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +114,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
apps/erpnext/erpnext/selling/doctype/sales_bom/sales_bom.py +27,Parent Item {0} must be not Stock Item and must be a Sales Item,Parent Item {0} nesmí být skladem a musí být prodejní položky
DocType: Item,Item Image (if not slideshow),Item Image (ne-li slideshow)
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,An Customer exists with same name,Zákazník existuje se stejným názvem
DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hodina Rate / 60) * Skutečná Provozní doba
DocType: SMS Log,SMS Log,SMS Log
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Náklady na dodávaných výrobků
DocType: Blog Post,Guest,Host
DocType: Quality Inspection,Get Specification Details,Získat Specifikace Podrobnosti
DocType: Lead,Interested,Zájemci
apps/erpnext/erpnext/config/manufacturing.py +14,Bill of Material,Bill of materiálu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},Od {0} do {1}
DocType: Item,Copy From Item Group,Kopírovat z bodu Group
DocType: Journal Entry,Opening Entry,Otevření Entry
apps/erpnext/erpnext/controllers/trends.py +33,{0} is mandatory,{0} je povinné
apps/erpnext/erpnext/config/setup.py +111,Contact master.,Kontakt master.
apps/erpnext/erpnext/accounts/doctype/account/account.py +87,Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.
DocType: Lead,Product Enquiry,Dotaz Product
DocType: Standard Reply,Owner,Majitel
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +13,Please enter company first,"Prosím, nejprave zadejte společnost"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +35,Please select Company first,"Prosím, vyberte první firma"
DocType: Employee Education,Under Graduate,Za absolventa
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +22,Target On,Target On
DocType: BOM,Total Cost,Celkové náklady
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +98,Reaming,Vystružování
DocType: Email Digest,Stub,Pahýl
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +8,Activity Log:,Aktivita Log:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +202,Item {0} does not exist in the system or has expired,Bod {0} neexistuje v systému nebo vypršela
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +43,Real Estate,Nemovitost
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +4,Statement of Account,Výpis z účtu
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +40,Pharmaceuticals,Farmaceutické
DocType: Expense Claim Detail,Claim Amount,Nárok Částka
DocType: Employee,Mr,Pan
DocType: Custom Script,Client,Klient
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/setup/page/setup_wizard/setup_wizard.js +571,Consumable,Spotřební
DocType: Upload Attendance,Import Log,Záznam importu
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.js +19,Send,Odeslat
DocType: SMS Center,All Contact,Vše Kontakt
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +159,Annual Salary,Roční Plat
DocType: Period Closing Voucher,Closing Fiscal Year,Uzavření fiskálního roku
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +69,Stock Expenses,Stock Náklady
DocType: Newsletter,Email Sent?,E-mail odeslán?
DocType: Journal Entry,Contra Entry,Contra Entry
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +89,Show Time Logs,Show Time Záznamy
DocType: Email Digest,Bank/Cash Balance,Bank / Cash Balance
DocType: Delivery Note,Installation Status,Stav instalace
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +97,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamítnuté množství se musí rovnat množství Přijaté u položky {0}
DocType: Item,Supply Raw Materials for Purchase,Dodávky suroviny pro nákup
apps/erpnext/erpnext/stock/get_item_details.py +134,Item {0} must be a Purchase Item,Bod {0} musí být Nákup položky
DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
All dates and employee combination in the selected period will come in the template, with existing attendance records","Stáhněte si šablony, vyplňte potřebné údaje a přiložte upravený soubor.
 Všechny termíny a zaměstnanec kombinaci ve zvoleném období přijde v šabloně, se stávajícími evidence docházky"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +496,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 +385,"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,Nastavení pro HR modul
DocType: SMS Center,SMS Center,SMS centrum
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +77,Straightening,Rovnací
DocType: BOM Replace Tool,New BOM,New BOM
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +132,There were no updates in the items selected for this digest.,Nebyly zjištěny žádné aktualizace ve vybraných položek pro tento digest.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +14,Countergravity casting,Countergravity lití
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +28,Newsletter has already been sent,Newsletter již byla odeslána
DocType: Lead,Request Type,Typ požadavku
DocType: Leave Application,Reason,Důvod
DocType: Purchase Invoice,The rate at which Bill Currency is converted into company's base currency,"Sazba, za kterou je Bill měny převeden do společnosti základní měny"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +13,Broadcasting,Vysílání
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +135,Execution,Provedení
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +362,The first user will become the System Manager (you can change this later).,První uživatel bude System Manager (lze později změnit).
apps/erpnext/erpnext/config/manufacturing.py +39,Details of the operations carried out.,Podrobnosti o prováděných operací.
DocType: Serial No,Maintenance Status,Status Maintenance
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +37,From Date should be within the Fiscal Year. Assuming From Date = {0},"Od data by měla být v rámci fiskálního roku. Za předpokladu, že od data = {0}"
DocType: Appraisal,Select the Employee for whom you are creating the Appraisal.,"Vyberte zaměstnance, pro kterého vytváříte hodnocení."
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +90,Cost Center {0} does not belong to Company {1},Náklady Center {0} nepatří do společnosti {1}
DocType: Customer,Individual,Individuální
apps/erpnext/erpnext/config/support.py +23,Plan for maintenance visits.,Plán pro návštěvy údržby.
DocType: SMS Settings,Enter url parameter for message,Zadejte url parametr zprávy
apps/erpnext/erpnext/config/selling.py +143,Rules for applying pricing and discount.,Pravidla pro používání cen a slevy.
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Ceník musí být použitelný pro nákup nebo prodej
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +90,Installation date cannot be before delivery date for Item {0},Datum Instalace nemůže být před datem dodání pro bod {0}
sites/assets/js/form.min.js +261,Start,Start
DocType: User,First Name,Křestní jméno
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +602,Your setup is complete. Refreshing.,Nastavení je dokončeno. Aktualizuji.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +11,Full-mold casting,Lití Full-forma
DocType: Offer Letter,Select Terms and Conditions,Vyberte Podmínky
DocType: Email Digest,Payments made during the digest period,Platby provedené v období digest
DocType: Production Planning Tool,Sales Orders,Prodejní objednávky
DocType: Purchase Taxes and Charges,Valuation,Ocenění
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +17,Set as Default,Nastavit jako výchozí
,Purchase Order Trends,Nákupní objednávka trendy
apps/erpnext/erpnext/config/hr.py +78,Allocate leaves for the year.,Přidělit listy za rok.
DocType: Earning Type,Earning Type,Výdělek Type
DocType: Email Digest,New Sales Orders,Nové Prodejní objednávky
DocType: Bank Reconciliation,Bank Account,Bankovní účet
DocType: Leave Type,Allow Negative Balance,Povolit záporný zůstatek
DocType: Email Digest,Receivable / Payable account will be identified based on the field Master Type,Pohledávka / Závazek účet bude určen na základě hlavního pole typu
DocType: Selling Settings,Default Territory,Výchozí Territory
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +52,Television,Televize
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +137,Gashing,Rozsekne
DocType: Production Order Operation,Updated via 'Time Log',"Aktualizováno přes ""Time Log"""
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +76,Account {0} does not belong to Company {1},Účet {0} nepatří do společnosti {1}
DocType: Naming Series,Series List for this Transaction,Řada seznam pro tuto transakci
apps/erpnext/erpnext/controllers/selling_controller.py +176,Reserved Warehouse required for stock Item {0} in row {1},Vyhrazeno Warehouse potřebný pro živočišnou item {0} v řadě {1}
DocType: Sales Invoice,Is Opening Entry,Je vstupní otvor
DocType: Supplier,Mention if non-standard receivable account applicable,Zmínka v případě nestandardní pohledávky účet použitelná
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +145,For Warehouse is required before Submit,Pro Sklad je povinné před Odesláním
DocType: Sales Partner,Reseller,Reseller
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +49,Please enter Company,"Prosím, zadejte společnost"
DocType: Delivery Note Item,Against Sales Invoice Item,Proti položce vydané faktury
,Production Orders in Progress,Zakázka na výrobu v Progress
DocType: Item,Auto-raise Material Request if quantity goes below re-order level in default warehouse,"Auto-raise Material žádosti, pokud množství klesne pod úroveň re-pořadí, ve výchozím skladu"
DocType: Journal Entry,Write Off Amount <=,Napište jednorázová částka <=
DocType: Lead,Address & Contact,Adresa a kontakt
apps/erpnext/erpnext/controllers/recurring_document.py +205,Next Recurring {0} will be created on {1},Další Opakující {0} bude vytvořen na {1}
DocType: POS Setting,Create Stock Ledger Entries when you submit a Sales Invoice,Vytvořte Stock Ledger záznamy při odeslání prodejní faktuře
DocType: Newsletter List,Total Subscribers,Celkem Odběratelé
DocType: Lead,Contact Name,Kontakt Jméno
DocType: Production Plan Item,SO Pending Qty,SO Pending Množství
DocType: Salary Manager,Creates salary slip for above mentioned criteria.,Vytvoří výplatní pásku na výše uvedených kritérií.
apps/erpnext/erpnext/templates/generators/item.html +21,No description given,No vzhledem k tomu popis
apps/erpnext/erpnext/config/buying.py +18,Request for purchase.,Žádost o koupi.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +106,Double housing,Double bydlení
DocType: Item,"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Jednotka měření této položky (např Kg, Unit, No, pár)."
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +157,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 +110,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/page/setup_wizard/install_fixtures.py +167,Leaves per Year,Listy za rok
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 +123,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}
DocType: Brand,Material Master Manager,Materiál Hlavní manažer
DocType: Bulk Email,Message,Zpráva
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +663,Pending Items {0} updated,Nevyřízené položky {0} Aktualizováno
DocType: Item Website Specification,Item Website Specification,Položka webových stránek Specifikace
DocType: Backup Manager,Dropbox Access Key,Dropbox Access Key
DocType: Payment Tool,Reference No,Referenční číslo
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +342,Leave Blocked,Nechte Blokováno
apps/erpnext/erpnext/stock/doctype/item/item.py +465,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 +306,Annual,Roční
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Reklamní Odsouhlasení Item
DocType: Purchase Invoice,In Words will be visible once you save the Purchase Invoice.,"Ve slovech budou viditelné, jakmile uložíte o nákupu."
DocType: Stock Entry,Sales Invoice No,Prodejní faktuře č
DocType: Material Request Item,Min Order Qty,Min Objednané množství
DocType: Lead,Do Not Contact,Nekontaktujte
DocType: Sales Invoice,The unique id for tracking all recurring invoices. It is generated on submit.,Unikátní ID pro sledování všech opakující faktury. To je generován na odeslat.
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +88,Software Developer,Software Developer
DocType: Item,Minimum Order Qty,Minimální objednávka Množství
DocType: Pricing Rule,Supplier Type,Dodavatel Type
DocType: Item,Publish in Hub,Publikovat v Hub
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +482,Item {0} is cancelled,Položka {0} je zrušen
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +620,Material Request,Požadavek na materiál
DocType: Bank Reconciliation,Update Clearance Date,Aktualizace Výprodej Datum
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +128,Wire brushing,Wire kartáčování
DocType: Employee,Relation,Vztah
apps/erpnext/erpnext/config/selling.py +23,Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
DocType: Purchase Receipt Item,Rejected Quantity,Zamítnuto Množství
DocType: Features Setup,"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Pole k dispozici v dodací list, cenovou nabídku, prodejní faktury odběratele"
DocType: SMS Settings,SMS Sender Name,SMS Sender Name
DocType: Contact,Is Primary Contact,Je primárně Kontakt
DocType: Notification Control,Notification Control,Oznámení Control
DocType: Lead,Suggestions,Návrhy
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Položka Skupina-moudrý rozpočty na tomto území. Můžete také sezónnosti nastavením distribuce.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +72,Please enter parent account group for warehouse {0},"Prosím, zadejte mateřskou skupinu účtu pro sklad {0}"
DocType: Supplier,Address HTML,Adresa HTML
DocType: Lead,Mobile No.,Mobile No.
DocType: Maintenance Schedule,Generate Schedule,Generování plán
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +80,Hubbing,Hubbing
DocType: Purchase Invoice Item,Expense Head,Náklady Head
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +86,Please select Charge Type first,"Prosím, vyberte druh tarifu první"
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Nejnovější
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +393,Max 5 characters,Max 5 znaků
DocType: Email Digest,New Quotations,Nové Citace
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +194,Select Your Language,Zvolit jazyk
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: Accounts Settings,Settings for Accounts,Nastavení účtů
apps/erpnext/erpnext/config/crm.py +80,Manage Sales Person Tree.,Správa obchodník strom.
DocType: Item,Synced With Hub,Synchronizovány Hub
DocType: Item,Variant Of,Varianta
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +35,Item {0} must be Service Item,Položka {0} musí být Service Item
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +297,Completed Qty can not be greater than 'Qty to Manufacture',"Dokončené množství nemůže být větší než ""Množství do výroby"""
DocType: DocType,Administrator,Správce
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +135,Laser drilling,Laserové vrtání
DocType: Stock UOM Replace Utility,New Stock UOM,Nových akcií UOM
DocType: Period Closing Voucher,Closing Account Head,Závěrečný účet hlava
DocType: Shopping Cart Settings,"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Přidat / Upravit </a>"
DocType: Employee,External Work History,Vnější práce History
apps/erpnext/erpnext/projects/doctype/task/task.py +86,Circular Reference Error,Kruhové Referenční Chyba
DocType: ToDo,Closed,Zavřeno
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"Ve slovech (export) budou viditelné, jakmile uložíte doručení poznámku."
DocType: Lead,Industry,Průmysl
DocType: Employee,Job Profile,Job Profile
DocType: Newsletter,Newsletter,Newsletter
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +83,Hydroforming,Hydroforming
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +48,Necking,Zúžení
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Upozornit e-mailem na tvorbu automatických Materiál Poptávka
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +29,Item is updated,Položka je aktualizována
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +26,Global POS Setting {0} already created for company {1},Global POS nastavení {0} již vytvořený pro společnost {1}
DocType: Comment,System Manager,Správce systému
DocType: Payment Reconciliation Invoice,Invoice Type,Typ faktury
DocType: Sales Invoice Item,Delivery Note,Dodací list
DocType: Backup Manager,Allow Dropbox Access,Povolit přístup Dropbox
DocType: Communication,Support Manager,Manažer podpory
DocType: Sales Order Item,Reserved Warehouse,Vyhrazeno Warehouse
apps/erpnext/erpnext/accounts/utils.py +182,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 +337,{0} entered twice in Item Tax,{0} vloženo dvakrát v Daňové Položce
DocType: Workstation,Rent Cost,Rent Cost
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +73,Please select month and year,Vyberte měsíc a rok
DocType: Purchase Invoice,"Enter email id separated by commas, invoice will be mailed automatically on particular date","Zadejte e-mail id odděleny čárkami, bude faktura bude zaslán automaticky na určité datum"
DocType: Employee,Company Email,Společnost E-mail
DocType: Workflow State,Refresh,obnovit
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 +59,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 +59,Total Order Considered,Celková objednávka Zvážil
DocType: Sales Invoice Item,Discount (%),Sleva (%)
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 +198,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,Tax Rate
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +510,Select Item,Select Položka
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +208,{0} {1} status is Stopped,{0} {1} status je zastavena
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +138,"Item: {0} managed batch-wise, can not be reconciled using \
					Stock Reconciliation, instead use Stock Entry","Item: {0} podařilo dávkové, nemůže být v souladu s použitím \
 Stock usmíření, použijte Reklamní Entry"
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +242,Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána
apps/erpnext/erpnext/accounts/doctype/account/account.js +54,Convert to non-Group,Převést na non-Group
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Purchase Receipt must be submitted,Příjmka musí být odeslána
DocType: Stock UOM Replace Utility,Current Stock UOM,Current Reklamní UOM
apps/erpnext/erpnext/config/stock.py +53,Batch (lot) of an Item.,Batch (lot) položky.
DocType: C-Form Invoice Detail,Invoice Date,Datum Fakturace
apps/erpnext/erpnext/stock/doctype/item/item.py +358,"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'","Jelikož jsou stávající skladové transakce za tuto položku, nelze změnit hodnoty ""Má pořadové číslo"", ""má Batch ne"", ""Je skladem"" a ""oceňování metoda"""
apps/erpnext/erpnext/templates/includes/footer_extension.html +6,Your email address,Vaše e-mailová adresa
DocType: Email Digest,Income booked for the digest period,Příjmy žlutou kartu za období digest
apps/erpnext/erpnext/config/setup.py +106,Supplier master.,Dodavatel master.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +191,Please see attachment,"Prosím, viz příloha"
DocType: Purchase Order,% Received,% Přijaté
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +108,Water jet cutting,Řezání vodním paprskem
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +22,Setup Already Complete!!,Setup již dokončen !!
,Finished Goods,Hotové zboží
DocType: Delivery Note,Instructions,Instrukce
DocType: Quality Inspection,Inspected By,Zkontrolován
DocType: Maintenance Visit,Maintenance Type,Typ Maintenance
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +69,Serial No {0} does not belong to Delivery Note {1},Pořadové číslo {0} není součástí dodávky Poznámka: {1}
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Položka Kontrola jakosti Parametr
DocType: Leave Application,Leave Approver Name,Nechte schvalovač Jméno
,Schedule Date,Plán Datum
DocType: Packed Item,Packed Item,Zabalená položka
apps/erpnext/erpnext/config/buying.py +54,Default settings for buying transactions.,Výchozí nastavení pro nákup transakcí.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +23,Activity Cost exists for Employee {0} against Activity Type - {1},Existuje Náklady aktivity pro zaměstnance {0} proti Typ aktivity - {1}
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +29,Please do NOT create Accounts for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,"Prosím, ne vytvářet účty pro zákazníky a dodavateli. Jsou vytvořeny přímo od zákazníka / dodavatele mistrů."
DocType: Currency Exchange,Currency Exchange,Směnárna
DocType: Purchase Invoice Item,Item Name,Název položky
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Credit Balance,Credit Balance
DocType: Employee,Widowed,Ovdovělý
DocType: Production Planning Tool,"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Položky, které je třeba požádat, které jsou ""Není skladem"" s ohledem na veškeré sklady na základě předpokládaného Množství a minimální Objednané množství"
DocType: Workstation,Working Hours,Pracovní doba
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Změnit výchozí / aktuální pořadové číslo existujícího série.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +57,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Je-li více pravidla pro tvorbu cen i nadále přednost, jsou uživatelé vyzváni k nastavení priority pro vyřešení konfliktu."
DocType: Stock Entry,Purchase Return,Nákup Return
,Purchase Register,Nákup Register
DocType: Item,"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Výběr ""Ano"" umožní tato položka přijít na odběratele, dodací list"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +212,Please enter Purchase Receipt No to proceed,Zadejte prosím doklad o koupi No pokračovat
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 +153,{0} ({1}) must have role 'Leave Approver',"{0} ({1}), musí mít roli ""Schvalovatel dovolených"""
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +39,Medical,Lékařský
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +124,Reason for losing,Důvod ztráty
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +35,Tube beading,Tube navlékání korálků
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +79,Workstation is closed on the following dates as per Holiday List: {0},Workstation je uzavřena v následujících dnech podle Prázdninový Seznam: {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +638,Make Maint. Schedule,Proveďte údržba. Plán
DocType: Employee,Single,Jednolůžkový
DocType: Account,Cost of Goods Sold,Náklady na prodej zboží
DocType: Purchase Invoice,Yearly,Ročně
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +217,Please enter Cost Center,"Prosím, zadejte nákladové středisko"
DocType: Sales Invoice Item,Sales Order,Prodejní objednávky
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +63,Avg. Selling Rate,Avg. Prodej Rate
DocType: Purchase Order,Start date of current order's period,Datum období současného objednávky Začátek
apps/erpnext/erpnext/utilities/transaction_base.py +113,Quantity cannot be a fraction in row {0},Množství nemůže být zlomek na řádku {0}
DocType: Purchase Invoice Item,Quantity and Rate,Množství a cena
DocType: Delivery Note,% Installed,% Instalováno
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +60,Please enter company name first,"Prosím, zadejte nejprve název společnosti"
DocType: BOM,Item Desription,Položka Desription
DocType: Buying Settings,Supplier Name,Dodavatel Name
DocType: Account,Is Group,Is Group
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +30,Thermoforming,Tvarování
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +65,Slitting,Kotoučová
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',"""DO Případu č ' nesmí být menší než ""Od Případu č '"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +99,Non Profit,Non Profit
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_list.js +7,Not Started,Nezahájeno
DocType: Lead,Channel Partner,Channel Partner
DocType: Account,Old Parent,Staré nadřazené
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Přizpůsobte si úvodní text, který jede jako součást tohoto e-mailu. Každá transakce je samostatný úvodní text."
DocType: Sales Taxes and Charges Template,Sales Master Manager,Sales manažer ve skupině Master
apps/erpnext/erpnext/config/manufacturing.py +66,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
DocType: Sales Order,Not Applicable,Nehodí se
apps/erpnext/erpnext/config/hr.py +140,Holiday master.,Holiday master.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +18,Shell molding,Shell lití
DocType: Material Request Item,Required Date,Požadovaná data
DocType: Delivery Note,Billing Address,Fakturační adresa
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +611,Please enter Item Code.,"Prosím, zadejte kód položky."
DocType: BOM,Costing,Rozpočet
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Je-li zaškrtnuto, bude částka daně považovat za již zahrnuty v tisku Rate / Tisk Částka"
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Celkem Množství
DocType: Employee,Health Concerns,Zdravotní Obavy
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +13,Unpaid,Nezaplacený
DocType: Packing Slip,From Package No.,Od č balíčku
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Cenné papíry a vklady
DocType: Features Setup,Imports,Importy
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +143,Adhesive bonding,Lepení
DocType: Job Opening,Description of a Job Opening,Popis jednoho volných pozic
apps/erpnext/erpnext/config/hr.py +28,Attendance record.,Účast rekord.
DocType: Bank Reconciliation,Journal Entries,Zápisy do Deníku
DocType: Sales Order Item,Used for Production Plan,Používá se pro výrobní plán
DocType: System Settings,Loading...,Nahrávám...
DocType: DocField,Password,Heslo
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +154,Fused deposition modeling,Nánosový modelování depozice
DocType: Manufacturing Settings,Time Between Operations (in mins),Doba mezi operací (v min)
DocType: Backup Manager,"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Poznámka: Zálohy a soubory nejsou odstraněny z Disku Google, budete muset odstranit ručně."
DocType: Customer,Buyer of Goods and Services.,Kupující zboží a služeb.
DocType: Journal Entry,Accounts Payable,Účty za úplatu
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +24,Add Subscribers,Přidat předplatitelé
sites/assets/js/erpnext.min.js +2,""" does not exists",""" Neexistuje"
DocType: Pricing Rule,Valid Upto,Valid aľ
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +514,List a few of your customers. They could be organizations or individuals.,Seznam několik svých zákazníků. Ty by mohly být organizace nebo jednotlivci.
DocType: Email Digest,Open Tickets,Otevřené Vstupenky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Direct Income,Přímý příjmů
DocType: Email Digest,Total amount of invoices received from suppliers during the digest period,Celková výše přijatých faktur od dodavatelů během období digest
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +29,"Can not filter based on Account, if grouped by Account","Nelze filtrovat na základě účtu, pokud seskupeny podle účtu"
DocType: Item,Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,"Dodací lhůta dnech je počet dní, o nichž je tato položka očekává ve skladu. Tento dnech je přitažené za vlasy v hmotné požadavku při výběru této položky."
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +83,Administrative Officer,Správní ředitel
DocType: Payment Tool,Received Or Paid,Přijaté nebo placené
DocType: Item,"Select ""Yes"" if this item is used for some internal purpose in your company.","Zvolte ""Ano"", pokud tato položka se používá pro některé interní účely ve vaší firmě."
DocType: Stock Entry,Difference Account,Rozdíl účtu
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +307,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/page/setup_wizard/fixtures/industry_type.py +19,Cosmetics,Kosmetika
DocType: DocField,Type,Typ
apps/erpnext/erpnext/stock/doctype/item/item.py +413,"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: Backup Manager,Email ids separated by commas.,E-mailové ID oddělené čárkami.
DocType: Communication,Subject,Předmět
DocType: Item,"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Zvolte ""Ano"", pokud je tato položka představuje nějakou práci, jako je vzdělávání, projektování, konzultace atd."
DocType: Shipping Rule,Net Weight,Hmotnost
DocType: Employee,Emergency Phone,Nouzový telefon
DocType: Backup Manager,Google Drive Access Allowed,Google Drive Přístup povolen
,Serial No Warranty Expiry,Pořadové č záruční lhůty
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +634,Do you really want to STOP this Material Request?,Opravdu chcete zastavit tento materiál požadavek?
DocType: Purchase Invoice Item,Item,Položka
DocType: Journal Entry,Difference (Dr - Cr),Rozdíl (Dr - Cr)
DocType: Account,Profit and Loss,Zisky a ztráty
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +310,Upcoming Calendar Events (max 10),Nadcházející Události v kalendáři (max 10)
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +101,New UOM must NOT be of type Whole Number,New UOM NESMÍ být typu celé číslo
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +47,Furniture and Fixture,Nábytek
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,"Sazba, za kterou Ceník měna je převedena na společnosti základní měny"
apps/erpnext/erpnext/setup/doctype/company/company.py +48,Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1}
DocType: Selling Settings,Default Customer Group,Výchozí Customer Group
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Je-li zakázat, ""zaokrouhlí celková"" pole nebude viditelný v jakékoli transakce"
DocType: BOM,Operating Cost,Provozní náklady
,Gross Profit,Hrubý Zisk
DocType: Production Planning Tool,Material Requirement,Materiál Požadavek
DocType: Company,Delete Company Transactions,Smazat transakcí Company
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +80,Item {0} is not Purchase Item,Položka {0} není Nákup položky
apps/erpnext/erpnext/controllers/recurring_document.py +187,"{0} is an invalid email address in 'Notification \
					Email Address'","{0} je neplatná e-mailová adresa v ""Oznámení \
 E-mailová adresa"""
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +44,Total Billing This Year:,Celkem Billing Tento rok:
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatků
DocType: Purchase Invoice,Supplier Invoice No,Dodavatelské faktury č
DocType: Territory,For reference,Pro srovnání
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +198,Closing (Cr),Uzavření (Cr)
DocType: Serial No,Warranty Period (Days),Záruční doba (dny)
DocType: Installation Note Item,Installation Note Item,Poznámka k instalaci bod
DocType: Job Applicant,Thread HTML,Thread HTML
DocType: Company,Ignore,Ignorovat
DocType: Backup Manager,Enter Verification Code,Zadejte ověřovací kód
apps/erpnext/erpnext/controllers/buying_controller.py +136,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Dodavatel Warehouse povinné pro subdodavatelskou doklad o zakoupení
DocType: Pricing Rule,Valid From,Platnost od
DocType: Sales Invoice,Total Commission,Celkem Komise
DocType: Pricing Rule,Sales Partner,Sales Partner
DocType: Buying Settings,Purchase Receipt Required,Příjmka je vyžadována
DocType: Monthly Distribution,"**Monthly Distribution** helps you distribute your budget across months if you have seasonality in your business.

To distribute a budget using this distribution, set this **Monthly Distribution** in the **Cost Center**","** Měsíční rozložení** vám pomůže váš rozpočet distribuovat do více měsíců, pokud Vaše podnikání ovlivňuje sezónnost.

 Chcete-li distribuovat rozpočet pomocí tohoto rozdělení, nastavte toto ** měsíční rozložení ** v ** nákladovém středisku **"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +172,No records found in the Invoice table,Nalezené v tabulce faktury Žádné záznamy
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +20,Please select Company and Party Type first,Vyberte první společnost a Party Typ
apps/erpnext/erpnext/config/accounts.py +79,Financial / accounting year.,Finanční / Účetní rok.
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +172,"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit"
DocType: Email Digest,New Supplier Quotations,Nového dodavatele Citace
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +616,Make Sales Order,Ujistěte se prodejní objednávky
DocType: Project Task,Project Task,Úkol Project
,Lead Id,Olovo Id
DocType: C-Form Invoice Detail,Grand Total,Celkem
DocType: About Us Settings,Website Manager,Správce webu
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Datum zahájení Fiskálního roku by nemělo být větší než datum ukončení
DocType: Warranty Claim,Resolution,Řešení
DocType: Sales Order,Display all the individual items delivered with the main items,Zobrazit všechny jednotlivé položky dodané s hlavními položkami
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +67,Payable Account,Splatnost účtu
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Opakujte zákazníci
DocType: Backup Manager,Sync with Google Drive,Synchronizace s Google Disku
DocType: Leave Control Panel,Allocate,Přidělit
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard_page.html +16,Previous,Předchozí
DocType: Stock Entry,Sales Return,Sales Return
DocType: Production Planning Tool,Select Sales Orders from which you want to create Production Orders.,"Vyberte prodejní objednávky, ze kterého chcete vytvořit výrobní zakázky."
apps/erpnext/erpnext/config/hr.py +120,Salary components.,Mzdové složky.
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Databáze potenciálních zákazníků.
apps/erpnext/erpnext/config/crm.py +17,Customer database.,Databáze zákazníků.
DocType: Quotation,Quotation To,Nabídka k
DocType: Lead,Middle Income,Středními příjmy
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +58,Opening (Cr),Otvor (Cr)
apps/erpnext/erpnext/accounts/utils.py +186,Allocated amount can not be negative,Přidělená částka nemůže být záporná
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +122,Tumbling,Tumbling
DocType: Purchase Order Item,Billed Amt,Účtovaného Amt
DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +111,Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0}
DocType: Event,Wednesday,Středa
DocType: Sales Invoice,Customer's Vendor,Prodejce zákazníka
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +197,Production Order is Mandatory,Výrobní zakázka je povinné
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +40,{0} {1} has a common territory {2},{0} {1} má společný území {2}
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +134,Proposal Writing,Návrh Psaní
apps/erpnext/erpnext/config/setup.py +85,Masters,Masters
apps/erpnext/erpnext/stock/stock_ledger.py +316,Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negativní Sklad Error ({6}) k bodu {0} ve skladu {1} na {2} {3} v {4} {5}
DocType: Fiscal Year Company,Fiscal Year Company,Fiskální rok Společnosti
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Time Log,Billed,Fakturováno
DocType: Batch,Batch Description,Popis Šarže
DocType: Delivery Note,Time at which items were delivered from warehouse,"Čas, kdy byly předměty dodány od skladu"
DocType: Sales Invoice,Sales Taxes and Charges,Prodej Daně a poplatky
DocType: Employee,Organization Profile,Profil organizace
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +90,Please setup numbering series for Attendance via Setup > Numbering Series,"Prosím, nastavení číslování série pro Účast přes Nastavení> Série číslování"
DocType: Email Digest,New Enquiries,Nové Dotazy
DocType: Employee,Reason for Resignation,Důvod rezignace
apps/erpnext/erpnext/config/hr.py +150,Template for performance appraisals.,Šablona pro hodnocení výkonu.
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti
apps/erpnext/erpnext/accounts/utils.py +50,{0} '{1}' not in Fiscal Year {2},{0} '{1}' není v fiskálním roce {2}
DocType: Buying Settings,Settings for Buying Module,Nastavení pro nákup modul
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +62,Please enter Purchase Receipt first,"Prosím, zadejte první doklad o zakoupení"
DocType: Buying Settings,Supplier Naming By,Dodavatel Pojmenování By
DocType: Maintenance Schedule,Maintenance Schedule,Plán údržby
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +34,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Pak se pravidla pro tvorbu cen jsou odfiltrovány založeny na zákazníka, skupiny zákazníků, území, dodavatel, dodavatel typ, kampaň, obchodní partner atd"
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_dropbox.py +126,Please install dropbox python module,"Prosím, nainstalujte dropbox python modul"
DocType: Employee,Passport Number,Číslo pasu
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +77,Manager,Manažer
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +512,From Purchase Receipt,Z příjemky
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +222,Same item has been entered multiple times.,Stejný bod byl zadán vícekrát.
DocType: SMS Settings,Receiver Parameter,Přijímač parametrů
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""Založeno Na"" a ""Seskupeno Podle"", nemůže být stejné"
DocType: Sales Person,Sales Person Targets,Obchodník cíle
sites/assets/js/form.min.js +253,To,na
apps/erpnext/erpnext/templates/includes/footer_extension.html +39,Please enter email address,Zadejte e-mailovou adresu
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +34,End tube forming,Konec trubice tvořící
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 +596,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
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Dodává Částka
DocType: Sales Invoice,Packing List,Balení Seznam
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Nákupní Objednávky odeslané Dodavatelům.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +42,Publishing,Publikování
DocType: Activity Cost,Projects User,Projekty uživatele
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Spotřeba
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +187,{0}: {1} not found in Invoice Details table,{0}: {1} nebyla nalezena v tabulce Podrobnosti Faktury
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +189,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Navštivte {0} musí být zrušena před zrušením této prodejní objednávky
DocType: Material Request,Material Transfer,Přesun materiálu
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +56,Opening (Dr),Opening (Dr)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +406,Posting timestamp must be after {0},Časová značka zadání musí být po {0}
apps/frappe/frappe/config/setup.py +59,Settings,Nastavení
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Přistál nákladů daně a poplatky
DocType: Production Order Operation,Actual Start Time,Skutečný čas začátku
DocType: BOM Operation,Operation Time,Provozní doba
sites/assets/js/list.min.js +5,More,Více
DocType: Communication,Sales Manager,Manažer prodeje
sites/assets/js/desk.min.js +555,Rename,Přejmenovat
DocType: Purchase Invoice,Write Off Amount,Odepsat Částka
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +51,Bending,Ohýbání
DocType: Leave Block List Allow,Allow User,Umožňuje uživateli
DocType: Journal Entry,Bill No,Bill No
DocType: Purchase Invoice,Quarterly,Čtvrtletně
DocType: Selling Settings,Delivery Note Required,Delivery Note Povinné
DocType: Sales Order Item,Basic Rate (Company Currency),Basic Rate (Company měny)
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +66,Please enter item details,"Prosím, zadejte podrobnosti položky"
DocType: Purchase Receipt,Other Details,Další podrobnosti
DocType: Account,Accounts,Účty
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +62,Marketing,Marketing
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +64,Straight shearing,Straight stříhání
DocType: Features Setup,To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Chcete-li sledovat položky v oblasti prodeje a nákupu dokumentů na základě jejich sériových čísel. To je možné také použít ke sledování detailů produktu záruční.
DocType: Purchase Receipt Item Supplied,Current Stock,Current skladem
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +81,Rejected Warehouse is mandatory against regected item,Zamítnuto Warehouse je povinná proti regected položky
DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
DocType: Employee,Provide email id registered in company,Poskytnout e-mail id zapsané ve firmě
DocType: Hub Settings,Seller City,Prodejce City
DocType: Email Digest,Next email will be sent on:,Další e-mail bude odeslán dne:
DocType: Offer Letter Term,Offer Letter Term,Nabídka Letter Term
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +23,Item {0} not found,Položka {0} nebyl nalezen
DocType: Bin,Stock Value,Reklamní Value
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +88,Tree Type,Tree Type
DocType: BOM Explosion Item,Qty Consumed Per Unit,Množství spotřebované na jednotku
DocType: Serial No,Warranty Expiry Date,Záruka Datum vypršení platnosti
DocType: Material Request Item,Quantity and Warehouse,Množství a sklad
DocType: Sales Invoice,Commission Rate (%),Výše provize (%)
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +141,"Against Voucher Type must be one of Sales Order, Sales Invoice or Journal Entry","Proti poukazu Type musí být jedním z prodejní objednávky, prodejní faktury nebo Journal Entry"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +138,Biomachining,Biomachining
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +6,Aerospace,Aerospace
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +19,Welcome,Vítejte
DocType: Journal Entry,Credit Card Entry,Vstup Kreditní karta
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +18,Task Subject,Úkol Předmět
apps/erpnext/erpnext/config/stock.py +28,Goods received from Suppliers.,Zboží od dodavatelů.
DocType: Communication,Open,Otevřít
DocType: Lead,Campaign Name,Název kampaně
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +197,Please enter Delivery Note No or Sales Invoice No to proceed,"Prosím, zadejte dodacího listu nebo prodejní faktury č pokračovat"
,Reserved,Rezervováno
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +650,Do you really want to UNSTOP,"Opravdu chcete, aby uvolnit"
DocType: Purchase Order,Supply Raw Materials,Dodávek surovin
DocType: Purchase Invoice,The date on which next invoice will be generated. It is generated on submit.,"Datum, kdy bude vygenerován příští faktury. To je generován na odeslat."
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Oběžná aktiva
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +108,{0} is not a stock Item,{0} není skladová položka
DocType: Mode of Payment Account,Default Account,Výchozí účet
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +155,Lead must be set if Opportunity is made from Lead,Vedoucí musí být nastavena pokud Opportunity je vyrobena z olova
DocType: Contact Us Settings,Address Title,Označení adresy
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +32,Please select weekly off day,"Prosím, vyberte týdenní off den"
DocType: Production Order Operation,Planned End Time,Plánované End Time
,Sales Person Target Variance Item Group-Wise,Prodej Osoba Cílová Odchylka Item Group-Wise
DocType: Backup Manager,Daily,Denně
apps/erpnext/erpnext/accounts/doctype/account/account.py +79,Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu
DocType: Delivery Note,Customer's Purchase Order No,Zákazníka Objednávka No
DocType: Employee,Cell Number,Číslo buňky
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Ztracený
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +139,You can not enter current voucher in 'Against Journal Entry' column,"Nelze zadat aktuální poukaz v ""Proti Zápis do deníku"" sloupci"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +24,Energy,Energie
DocType: Opportunity,Opportunity From,Příležitost Z
apps/erpnext/erpnext/config/hr.py +33,Monthly salary statement.,Měsíční plat prohlášení.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +434,"Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. \
						Pending Amount is {2}","Řádek č {0}: Částka nesmí být větší než Až do částky proti Expense nároku {1}. \
 Až Částka je {2}"
DocType: Item Group,Website Specifications,Webových stránek Specifikace
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +198,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 +284,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
apps/erpnext/erpnext/templates/pages/ticket.py +27,Please write something,Napište něco
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.,Účetní Přihlášky lze proti koncové uzly. Záznamy proti skupinám nejsou povoleny.
DocType: ToDo,High,Vysoké
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +364,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nelze deaktivovat nebo zrušit BOM, jak to souvisí s ostatními kusovníky"
DocType: Opportunity,Maintenance,Údržba
DocType: User,Male,Muž
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +181,Purchase Receipt number required for Item {0},Číslo příjmky je potřeba pro položku {0}
DocType: Item Attribute Value,Item Attribute Value,Položka Hodnota atributu
apps/erpnext/erpnext/config/crm.py +54,Sales campaigns.,Prodej kampaně.
DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Standardní daň šablona, ​​která může být použita pro všechny prodejních transakcí. Tato šablona může obsahovat seznam daňových hlav a také další náklady / příjmy hlavy jako ""doprava"", ""pojištění"", ""manipulace"" atd. 

 #### Poznámka: 

 daňovou sazbu, vy definovat zde bude základní sazba daně pro všechny ** položky **. Pokud jsou položky ** **, které mají různé ceny, musí být přidány v ** Položka daních ** stůl v ** položky ** mistra.

 #### Popis sloupců 

 1. Výpočet Type: 
 - To může být na ** Čistý Total ** (což je součet základní částky).
 - ** Na předchozí řady Total / Částka ** (pro kumulativní daní a poplatků). Zvolíte-li tuto možnost, bude daň se použije jako procento z předchozí řady (v daňové tabulky) množství nebo celkem.
 - ** Aktuální ** (jak je uvedeno).
 2. Účet Hlava: kniha účtu, pod kterým se bude tato daň rezervovat 
 3. Nákladové středisko: V případě, že daň / poplatek je příjmem (jako poštovné) nebo nákladů je třeba rezervovat na nákladové středisko.
 4. Popis: Popis daně (které budou vytištěny v faktur / uvozovek).
 5. Rate: Sazba daně.
 6. Částka: Částka daně.
 7. Celkem: Kumulativní celková k tomuto bodu.
 8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).
 9. Je to poplatek v ceně do základní sazby ?: Pokud se to ověřit, znamená to, že tato daň nebude zobrazen pod tabulkou položky, ale budou zahrnuty do základní sazby v hlavním položce tabulky. To je užitečné, pokud chcete dát paušální cenu (včetně všech poplatků), ceny pro zákazníky."
DocType: Serial No,Purchase Returned,Nákup Vráceno
DocType: Employee,Bank A/C No.,"Č, bank. účtu"
DocType: Email Digest,Scheduler Failed Events,Plánovač Nepodařilo Events
DocType: Expense Claim,Project,Projekt
DocType: Quality Inspection Reading,Reading 7,Čtení 7
DocType: Address,Personal,Osobní
DocType: Expense Claim Detail,Expense Claim Type,Náklady na pojistná Type
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Výchozí nastavení Košík
apps/erpnext/erpnext/controllers/accounts_controller.py +255,"Journal Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Zápis do deníku {0} je spojen proti řádu {1}, zkontrolujte, zda by měl být tažen za pokrok v této faktuře."
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +12,Biotechnology,Biotechnologie
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +108,Office Maintenance Expenses,Náklady Office údržby
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +52,Hemming,Hemming
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +64,Please enter Item first,"Prosím, nejdřív zadejte položku"
DocType: Account,Liability,Odpovědnost
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +61,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionována Částka nemůže být větší než reklamace Částka v řádku {0}.
DocType: Company,Default Cost of Goods Sold Account,Výchozí Náklady na prodané zboží účtu
apps/erpnext/erpnext/stock/get_item_details.py +238,Price List not selected,Ceník není zvolen
DocType: Employee,Family Background,Rodinné poměry
DocType: Salary Manager,Send Email,Odeslat email
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +85,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 +43,"To filter based on Party, select Party Type first","Chcete-li filtrovat na základě Party, vyberte typ Party první"
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Nos,Nos
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Odsouhlasení Detail
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588,My Invoices,Moje Faktury
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +39,No employee found,Žádný zaměstnanec nalezeno
DocType: Purchase Order,Stopped,Zastaveno
DocType: SMS Center,All Customer Contact,Vše Kontakt Zákazník
apps/erpnext/erpnext/config/stock.py +64,Upload stock balance via csv.,Nahrát nutnosti rovnováhy prostřednictvím CSV.
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +32,Send Now,Odeslat nyní
,Support Analytics,Podpora Analytics
DocType: Item,Website Warehouse,Sklad pro web
DocType: Sales Invoice,"The day of the month on which auto invoice will be generated e.g. 05, 28 etc","Den měsíce, ve kterém auto faktura bude generován například 05, 28 atd"
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Skóre musí být menší než nebo rovna 5
apps/erpnext/erpnext/config/accounts.py +159,C-Form records,C-Form záznamy
DocType: Email Digest,Email Digest Settings,Nastavení e-mailu Digest
apps/erpnext/erpnext/config/support.py +13,Support queries from customers.,Podpora dotazy ze strany zákazníků.
DocType: Bin,Moving Average Rate,Klouzavý průměr
DocType: Production Planning Tool,Select Items,Vyberte položky
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +294,{0} against Bill {1} dated {2},{0} proti účtu {1} ze dne {2}
DocType: Communication,Reference Name,Název reference
DocType: Maintenance Visit,Completion Status,Dokončení Status
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, Sales BOM, Sales Order, Serial No","Chcete-li sledovat značku v těchto dokumentech dodacího listu Opportunity, materiál Request, bod, objednávky, nákup poukazu, nakupují stvrzenka, cenovou nabídku, prodejní faktury, Sales BOM, prodejní objednávky, pořadové číslo"
DocType: Production Order,Target Warehouse,Target Warehouse
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +23,Expected Delivery Date cannot be before Sales Order Date,"Očekávané datum dodání, nemůže být před Sales pořadí Datum"
DocType: Upload Attendance,Import Attendance,Importovat Docházku
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +17,All Item Groups,Všechny skupiny položek
DocType: Salary Manager,Activity Log,Aktivita Log
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +30,Net Profit / Loss,Čistý zisk / ztráta
apps/erpnext/erpnext/config/setup.py +64,Automatically compose message on submission of transactions.,Automaticky napsat vzkaz na předkládání transakcí.
DocType: Production Order,Item To Manufacture,Bod K výrobě
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +15,Permanent mold casting,Trvalé odlévání forem
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žer
DocType: Notification Control,Delivery Note Message,Delivery Note Message
DocType: Expense Claim,Expenses,Výdaje
,Purchase Receipt Trends,Doklad o koupi Trendy
DocType: Appraisal,Select template from which you want to get the Goals,"Vyberte šablonu, ze kterého chcete získat cílů"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +72,Research & Development,Výzkum a vývoj
,Amount to Bill,Částka k Fakturaci
DocType: Company,Registration Details,Registrace Podrobnosti
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +74,Staking,Sázet
DocType: Item Reorder,Re-Order Qty,Re-Order Množství
DocType: Leave Block List Date,Leave Block List Date,Nechte Block List Datum
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +23,Scheduled to send to {0},Plánované poslat na {0}
DocType: Pricing Rule,Price or Discount,Cena nebo Sleva
DocType: Sales Team,Incentives,Pobídky
apps/erpnext/erpnext/config/hr.py +38,Performance appraisal.,Hodnocení výkonu.
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Hodnota projektu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +636,Make Maint. Visit,Proveďte údržba. Návštěva
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +68,Cannot carry forward {0},Nelze převést {0}
apps/erpnext/erpnext/accounts/doctype/account/account.py +73,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zůstatek na účtu již v Credit, není dovoleno stanovit ""Balance musí být"" jako ""debet"""
DocType: Account,Balance must be,Zůstatek musí být
DocType: Hub Settings,Publish Pricing,Publikovat Ceník
DocType: Email Digest,New Purchase Receipts,Nové Nákup Příjmy
DocType: Notification Control,Expense Claim Rejected Message,Zpráva o zamítnutí úhrady výdajů
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +144,Nailing,Báječný
,Available Qty,Množství k dispozici
DocType: Purchase Taxes and Charges,On Previous Row Total,Na předchozí řady Celkem
DocType: Salary Slip,Working Days,Pracovní dny
DocType: Serial No,Incoming Rate,Příchozí Rate
DocType: Packing Slip,Gross Weight,Hrubá hmotnost
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +409,The name of your company for which you are setting up this system.,"Název vaší společnosti, pro kterou nastavení tohoto systému."
DocType: HR Settings,Include holidays in Total no. of Working Days,Zahrnout dovolenou v celkovém. pracovních dní
DocType: Job Applicant,Hold,Držet
DocType: Employee,Date of Joining,Datum přistoupení
DocType: Naming Series,Update Series,Řada Aktualizace
DocType: Supplier Quotation,Is Subcontracted,Subdodavatelům
DocType: Item Attribute,Item Attribute Values,Položka Hodnoty atributů
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +3,View Subscribers,Zobrazit Odběratelé
DocType: Purchase Invoice Item,Purchase Receipt,Příjemka
,Received Items To Be Billed,"Přijaté položek, které mají být účtovány"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +113,Abrasive blasting,Abrazivní tryskání
DocType: Employee,Ms,Paní
apps/erpnext/erpnext/config/accounts.py +138,Currency exchange rate master.,Devizový kurz master.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +242,Unable to find Time Slot in the next {0} days for Operation {1},Nelze najít časový úsek v příštích {0} dní k provozu {1}
DocType: Production Order,Plan material for sub-assemblies,Plán materiál pro podsestavy
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +423,BOM {0} must be active,BOM {0} musí být aktivní
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.js +22,Set Status as Available,Nastavit stav as k dispozici
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +26,Please select the document type first,Vyberte první typ dokumentu
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +68,Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušit Materiál Návštěvy {0} před zrušením tohoto návštěv údržby
DocType: Salary Slip,Leave Encashment Amount,Nechte inkasa Částka
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +223,Serial No {0} does not belong to Item {1},Pořadové číslo {0} nepatří k bodu {1}
apps/erpnext/erpnext/accounts/page/pos/pos_page.html +13,Make new POS Setting,Proveďte nové nastavení POS
DocType: Purchase Receipt Item Supplied,Required Qty,Požadované množství
DocType: Bank Reconciliation,Total Amount,Celková částka
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +31,Internet Publishing,Internet Publishing
DocType: Production Planning Tool,Production Orders,Výrobní Objednávky
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +30,Balance Value,Zůstatek Hodnota
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Sales Ceník
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +69,Publish to sync items,Publikování synchronizovat položky
DocType: Purchase Receipt,Range,Rozsah
DocType: Supplier,Default Payable Accounts,Výchozí úplatu účty
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +40,Employee {0} is not active or does not exist,Zaměstnanec {0} není aktivní nebo neexistuje
DocType: Features Setup,Item Barcode,Položka Barcode
apps/erpnext/erpnext/stock/doctype/item/item.py +193,Item Variants {0} updated,Bod Varianty {0} aktualizováno
DocType: Quality Inspection Reading,Reading 6,Čtení 6
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Záloha přijaté faktury
DocType: Address,Shop,Obchod
DocType: Hub Settings,Sync Now,Sync teď
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +191,Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Výchozí účet Bank / Cash budou automaticky aktualizovány v POS faktury, pokud je zvolen tento režim."
DocType: Employee,Permanent Address Is,Trvalé bydliště je
DocType: Production Order Operation,Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +471,The Brand,Brand
apps/erpnext/erpnext/controllers/status_updater.py +123,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: Payment Reconciliation Payment,Purchase Invoice,Přijatá faktura
DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail No
DocType: Stock Entry,Total Outgoing Value,Celková hodnota Odchozí
DocType: Lead,Request for Information,Žádost o informace
DocType: Payment Tool,Paid,Placený
DocType: Salary Slip,Total in words,Celkem slovy
DocType: Material Request Item,Lead Time Date,Lead Time data
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +127,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
apps/erpnext/erpnext/config/stock.py +23,Shipments to customers.,Zásilky zákazníkům.
DocType: Purchase Invoice Item,Purchase Order Item,Položka vydané objednávky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Indirect Income,Nepřímé příjmy
DocType: Contact Us Settings,Address Line 1,Adresní řádek 1
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +50,Variance,Odchylka
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +390,Company Name,Název společnosti
DocType: SMS Center,Total Message(s),Celkem zpráv (y)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +508,Select Item for Transfer,Vybrat položku pro převod
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Vyberte účet šéf banky, kde byla uložena kontrola."
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Povolit uživateli upravovat Ceník Cena při transakcích
DocType: Pricing Rule,Max Qty,Max Množství
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +125,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/page/setup_wizard/fixtures/industry_type.py +15,Chemical,Chemický
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +660,All items have already been transferred for this Production Order.,Všechny položky již byly převedeny na výrobu tohoto řádu.
DocType: Salary Manager,Select Payroll Year and Month,Vyberte Payroll rok a měsíc
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""",Přejděte na příslušné skupiny (obvykle využití finančních prostředků&gt; oběžných aktiv&gt; bankovních účtů a vytvořit nový účet (kliknutím na Přidat dítě) typu &quot;Bank&quot;
DocType: Workstation,Electricity Cost,Cena elektřiny
DocType: HR Settings,Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin
DocType: Comment,Unsubscribed,Odhlášen z odběru
DocType: Opportunity,Walk In,Vejít
DocType: Item,Inspection Criteria,Inspekční Kritéria
apps/erpnext/erpnext/config/accounts.py +96,Tree of finanial Cost Centers.,Strom finanial nákladových středisek.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +472,Upload your letter head and logo. (you can edit them later).,Nahrajte svůj dopis hlavu a logo. (Můžete je upravit později).
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +151,White,Bílá
DocType: SMS Center,All Lead (Open),Všechny Lead (Otevřeny)
DocType: Purchase Invoice,Get Advances Paid,Získejte zaplacené zálohy
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +360,Attach Your Picture,Připojit svůj obrázek
DocType: Journal Entry,Total Amount in Words,Celková částka slovy
DocType: Workflow State,Stop,Stop
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,"Došlo k chybě. Jedním z důvodů by mohlo být pravděpodobné, že jste uložili formulář. Obraťte se prosím na support@erpnext.com Pokud problém přetrvává."
DocType: Purchase Order,% of materials billed against this Purchase Order.,% Materiálů fakturovaných proti této objednávce.
apps/erpnext/erpnext/controllers/selling_controller.py +155,Order Type must be one of {0},Typ objednávky musí být jedním z {0}
DocType: Lead,Next Contact Date,Další Kontakt Datum
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +34,Opening Qty,Otevření POČET
DocType: Holiday List,Holiday List Name,Jméno Holiday Seznam
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +163,Stock Options,Akciové opce
DocType: Expense Claim,Expense Claim,Hrazení nákladů
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +164,Qty for {0},Množství pro {0}
DocType: Leave Application,Leave Application,Leave Application
apps/erpnext/erpnext/config/hr.py +77,Leave Allocation Tool,Nechte přidělení nástroj
DocType: Leave Block List,Leave Block List Dates,Nechte Block List termíny
DocType: Email Digest,Buying & Selling,Nákup a prodej
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +55,Trimming,Ořezávání
DocType: Workstation,Net Hour Rate,Net Hour Rate
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Přistál Náklady doklad o koupi
DocType: Packing Slip Item,Packing Slip Item,Balení Slip Item
DocType: POS Setting,Cash/Bank Account,Hotovostní / Bankovní účet
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +58,Removed items with no change in quantity or value.,Odstraněné položky bez změny množství nebo hodnoty.
DocType: Delivery Note,Delivery To,Doručení do
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 být negativní
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +198,"Row {0}: Party / Account does not match with \
							Customer / Debit To in {1}","Row {0}: Party / Account neodpovídá \
 Customer / debetní v {1}"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +102,Filing,Podání
apps/erpnext/erpnext/templates/form_grid/item_grid.html +67,Discount,Sleva
DocType: Features Setup,Purchase Discounts,Nákup Slevy
DocType: Stock Entry,This will override Difference Account in Item,To přepíše Difference účet v položce
DocType: Workstation,Wages,Mzdy
DocType: Time Log,Will be updated only if Time Log is 'Billable',"Bude aktualizována pouze v případě, Time Log je &quot;Zúčtovatelná&quot;"
DocType: Project,Internal,Interní
DocType: Task,Urgent,Naléhavý
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +97,Please specify a valid Row ID for row {0} in table {1},Zadejte prosím platný řádek ID řádku tabulky {0} {1}
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +76,This Time Log conflicts with {0} for {1},To je v rozporu Time Log s {0} na {1}
DocType: Sales BOM,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".

For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Sales BOM Item.

Note: BOM = Bill of Materials","Souhrnný skupina ** položek ** do jiné položky ** **. To je užitečné, pokud svazování některé položky ** ** do balíčku a budete udržovat zásoby balených ** položky ** a ne součet ** položky **. 

 Balíček ** položky ** bude mít ""je skladem"" jako ""No"" a ""Je Sales Item"" jako ""Yes"".

 Například: Pokud prodáváte notebooky a batohy odděleně a mají speciální cenu, pokud zákazník koupí oba, pak Laptop + Backpack bude nový Sales BOM položky.

 Poznámka: BOM = Bill of Materials"
DocType: Item,Manufacturer,Výrobce
DocType: Landed Cost Item,Purchase Receipt Item,Položka příjemky
DocType: Sales Order,PO Date,PO Datum
DocType: Serial No,Sales Returned,Sales Vrácené
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Vyhrazeno Warehouse v prodejní objednávky / hotových výrobků Warehouse
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +65,Selling Amount,Prodejní Částka
apps/erpnext/erpnext/projects/doctype/project/project.js +37,Time Logs,Čas Záznamy
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Jste Expense schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
DocType: Serial No,Creation Document No,Tvorba dokument č
DocType: Issue,Issue,Problém
apps/erpnext/erpnext/config/stock.py +136,"Attributes for Item Variants. e.g Size, Color etc.","Atributy pro položky varianty. například velikost, barva atd."
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +30,WIP Warehouse,WIP Warehouse
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +204,Serial No {0} is under maintenance contract upto {1},Pořadové číslo {0} je na základě smlouvy o údržbě aľ {1}
DocType: BOM Operation,Operation,Operace
DocType: Lead,Organization Name,Název organizace
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +385,POS Setting required to make POS Entry,"POS Nastavení požadováno, aby POS položky"
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,"Položka musí být přidány pomocí ""získat předměty z kupní příjmy"" tlačítkem"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Sales Expenses,Prodejní náklady
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +159,Standard Buying,Standardní Nakupování
DocType: GL Entry,Against,Proti
DocType: Item,Default Selling Cost Center,Výchozí Center Prodejní cena
DocType: Sales Partner,Implementation Partner,Implementačního partnera
DocType: Purchase Invoice,Contact Info,Kontaktní informace
DocType: Packing Slip,Net Weight UOM,Hmotnost UOM
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +477,Make Purchase Receipt,Proveďte doklad o koupi
DocType: Item,Default Supplier,Výchozí Dodavatel
DocType: Shipping Rule Condition,Shipping Rule Condition,Přepravní Pravidlo Podmínka
DocType: Features Setup,Miscelleneous,Miscelleneous
DocType: Holiday List,Get Weekly Off Dates,Získejte týdenní Off termíny
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +30,End Date can not be less than Start Date,Datum ukončení nesmí být menší než data zahájení
DocType: Sales Person,Select company name first.,Vyberte název společnosti jako první.
DocType: Sales BOM Item,Sales BOM Item,Sales BOM Item
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +87,Dr,Dr
apps/erpnext/erpnext/stock/doctype/item/item.py +317,"Item must be a purchase item, as it is present in one or many Active BOMs","Položka musí být nákup bod, protože je přítomna v jedné nebo mnoha Active kusovníky"
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Nabídka obdržená od Dodavatelů.
DocType: Journal Entry Account,Against Purchase Invoice,Proti nákupní faktuře
apps/erpnext/erpnext/controllers/selling_controller.py +21,To {0} | {1} {2},Chcete-li {0} | {1} {2}
DocType: Time Log Batch,updated via Time Logs,aktualizovat přes čas Záznamy
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Průměrný věk
apps/erpnext/erpnext/templates/includes/cart.js +59,Go ahead and add something to your cart.,Nyní můžete přidat položky do Vašeho košíku.
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/setup/page/setup_wizard/setup_wizard.js +537,List a few of your suppliers. They could be organizations or individuals.,Seznam několik svých dodavatelů. Ty by mohly být organizace nebo jednotlivci.
DocType: Supplier,Default Currency,Výchozí měna
DocType: Contact,Enter designation of this Contact,Zadejte označení této Kontakt
DocType: Contact Us Settings,Address,Adresa
DocType: Expense Claim,From Employee,Od Zaměstnance
apps/erpnext/erpnext/accounts/utils.py +39,{0} {1} not in any Fiscal Year. For more details check {2}.,{0} {1} v žádném fiskálním roce. Pro více informací klikněte {2}.
apps/erpnext/erpnext/controllers/accounts_controller.py +269,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,"Upozornění: Systém nebude kontrolovat nadfakturace, protože částka za položku na {1} je nula {0}"
DocType: Journal Entry,Make Difference Entry,Učinit vstup Rozdíl
DocType: Upload Attendance,Attendance From Date,Účast Datum od
DocType: Appraisal Template Goal,Key Performance Area,Key Performance Area
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +53,Transportation,Doprava
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +393,{0} {1} must be submitted,{0} {1} musí být odeslaný
DocType: SMS Center,Total Characters,Celkový počet znaků
apps/erpnext/erpnext/controllers/buying_controller.py +140,Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detail
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Platba Odsouhlasení faktury
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Contribution %,Příspěvek%
DocType: Item,website page link,webové stránky odkaz na stránku
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +191,Let's prepare the system for first use.,Pojďme připravit systém pro první použití.
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registrace firmy čísla pro váš odkaz. Daňové čísla atd
DocType: Sales Partner,Distributor,Distributor
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Nákupní košík Shipping Rule
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +195,Production Order {0} must be cancelled before cancelling this Sales Order,Výrobní zakázka {0} musí být zrušena před zrušením této prodejní objednávky
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +53,Budget cannot be set for Group Cost Centers,Rozpočet není možno nastavit pro středisek Skupina nákladová
,Ordered Items To Be Billed,Objednané zboží fakturovaných
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +21,Select Time Logs and Submit to create a new Sales Invoice.,Vyberte Time protokolů a předložit k vytvoření nové prodejní faktury.
DocType: Global Defaults,Global Defaults,Globální Výchozí
DocType: Salary Slip,Deductions,Odpočty
DocType: Purchase Invoice,Start date of current invoice's period,Datum období současného faktury je Začátek
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +23,This Time Log Batch has been billed.,To Batch Time Log bylo účtováno.
apps/erpnext/erpnext/crm/doctype/lead/lead.js +32,Create Opportunity,Vytvořit příležitost
DocType: Salary Slip,Leave Without Pay,Nechat bez nároku na mzdu
DocType: Supplier,Communications,Komunikace
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +275,Capacity Planning Error,Plánování kapacit Chyba
DocType: Lead,Consultant,Konzultant
DocType: Salary Slip,Earnings,Výdělek
DocType: Sales Invoice Advance,Sales Invoice Advance,Prodejní faktury Advance
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +404,Nothing to request,Nic požadovat
apps/erpnext/erpnext/projects/doctype/task/task.py +37,'Actual Start Date' can not be greater than 'Actual End Date',"""Skutečné datum zahájení"" nemůže být větší než ""Aktuální datum ukončení"""
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +70,Management,Řízení
apps/erpnext/erpnext/config/projects.py +33,Types of activities for Time Sheets,Typy činností pro Time listy
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +13,Investment casting,Investiční lití
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +45,Either debit or credit amount is required for {0},Buď debetní nebo kreditní částka je vyžadována pro {0}
DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To bude připojen na položku zákoníku varianty. Například, pokud vaše zkratka je ""SM"", a položka je kód ""T-SHIRT"", položka kód varianty bude ""T-SHIRT-SM"""
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Čistá Pay (slovy) budou viditelné, jakmile uložíte výplatní pásce."
apps/frappe/frappe/core/doctype/user/user_list.js +12,Active,Aktivní
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +149,Blue,Modrý
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +120,Further nodes can be only created under 'Group' type nodes,"Další uzly mohou být pouze vytvořena v uzlech typu ""skupiny"""
DocType: Item,UOMs,UOMs
apps/erpnext/erpnext/stock/utils.py +167,{0} valid serial nos for Item {1},{0} platí pořadová čísla pro položky {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +58,Item Code cannot be changed for Serial No.,Kód položky nemůže být změněn pro Serial No.
DocType: Purchase Order Item,UOM Conversion Factor,UOM Conversion Factor
DocType: Stock Settings,Default Item Group,Výchozí bod Group
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +155,Laminated object manufacturing,Vrstvené objektu výrobní
apps/erpnext/erpnext/config/buying.py +13,Supplier database.,Databáze dodavatelů.
DocType: Account,Balance Sheet,Rozvaha
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +596,Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +44,Stretch forming,Stretch tváření
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 +203,"Further accounts can be made under Groups, but entries can be made against non-Groups","Další účty mohou být vyrobeny v rámci skupiny, ale údaje lze proti non-skupin"
apps/erpnext/erpnext/config/hr.py +125,Tax and other salary deductions.,Daňové a jiné platové srážky.
DocType: Lead,Lead,Olovo
DocType: Email Digest,Payables,Závazky
DocType: Account,Warehouse,Sklad
,Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci
DocType: Purchase Invoice Item,Net Rate,Čistá míra
DocType: Backup Manager,Database Folder ID,číslo databázového adresára
DocType: Purchase Invoice Item,Purchase Invoice Item,Položka přijaté faktury
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +50,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Sériové Ledger Přihlášky a GL položky jsou zveřejňována pro vybrané Nákupní Příjmy
DocType: Holiday,Holiday,Dovolená
DocType: Event,Saturday,Sobota
DocType: Leave Control Panel,Leave blank if considered for all branches,"Ponechte prázdné, pokud se to považuje za všechny obory"
,Daily Time Log Summary,Denní doba prihlásenia - súhrn
DocType: DocField,Label,Popisek
DocType: Payment Reconciliation,Unreconciled Payment Details,Smířit platbě
DocType: Global Defaults,Current Fiscal Year,Aktuální fiskální rok
DocType: Global Defaults,Disable Rounded Total,Zakázat Zaoblený Celkem
DocType: Lead,Call,Volání
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,'Entries' cannot be empty,"""Položky"" nemůžou být prázdné"
apps/erpnext/erpnext/utilities/transaction_base.py +72,Duplicate row {0} with same {1},Duplicitní řádek {0} se stejným {1}
,Trial Balance,Trial Balance
sites/assets/js/erpnext.min.js +2,"Grid ""","Grid """
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +145,Please select prefix first,"Prosím, vyberte první prefix"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +133,Research,Výzkum
DocType: Maintenance Visit Purpose,Work Done,Odvedenou práci
DocType: Employee,User ID,User ID
DocType: Communication,Sent,Odesláno
apps/erpnext/erpnext/accounts/doctype/account/account.js +57,View Ledger,View Ledger
DocType: Cost Center,Lft,LFT
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Nejstarší
apps/erpnext/erpnext/stock/doctype/item/item.py +387,"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: Sales Order,Delivery Status,Delivery Status
DocType: Production Order,Manufacture against Sales Order,Výroba na odběratele
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +443,Rest Of The World,Zbytek světa
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +72,The Item {0} cannot have Batch,Položka {0} nemůže mít dávku
,Budget Variance Report,Rozpočet Odchylka Report
DocType: Salary Slip,Gross Pay,Hrubé mzdy
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +186,Dividends Paid,Dividendy placené
DocType: Stock Reconciliation,Difference Amount,Rozdíl Částka
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +192,Retained Earnings,Nerozdělený zisk
DocType: Purchase Order,Required raw materials issued to the supplier for producing a sub - contracted item.,Potřebné suroviny vydaných dodavateli pro výrobu sub - smluvně položka.
DocType: BOM Item,Item Description,Položka Popis
DocType: Payment Tool,Payment Mode,Způsob platby
DocType: Purchase Invoice,Is Recurring,Je Opakující
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +153,Direct metal laser sintering,Přímý plechu laserem spékání
DocType: Purchase Order,Supplied Items,Dodávané položky
DocType: Production Order,Qty To Manufacture,Množství K výrobě
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Udržovat stejnou sazbu po celou kupní cyklu
DocType: Opportunity Item,Opportunity Item,Položka Příležitosti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Temporary Opening,Dočasné Otevření
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +40,Cryorolling,Cryorolling
,Employee Leave Balance,Zaměstnanec Leave Balance
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +101,Balance for Account {0} must always be {1},Zůstatek na účtě {0} musí být vždy {1}
DocType: Sales Invoice,More Info,Více informací
DocType: Address,Address Type,Typ adresy
DocType: Purchase Receipt,Rejected Warehouse,Zamítnuto Warehouse
DocType: GL Entry,Against Voucher,Proti poukazu
DocType: Item,Default Buying Cost Center,Výchozí Center Nákup Cost
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +42,Item {0} must be Sales Item,Položka {0} musí být Sales Item
,Accounts Payable Summary,Splatné účty Shrnutí
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +159,Not authorized to edit frozen Account {0},Není povoleno upravovat zmrazený účet {0}
DocType: Journal Entry,Get Outstanding Invoices,Získat neuhrazených faktur
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +55,Sales Order {0} is not valid,Prodejní objednávky {0} není platný
DocType: Email Digest,New Stock Entries,Nových akcií Příspěvky
apps/erpnext/erpnext/setup/doctype/company/company.py +161,"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +140,Small,Malý
DocType: Employee,Employee Number,Počet zaměstnanců
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +65,Case No(s) already in use. Try from Case No {0},Případ číslo (čísla) již v provozu. Zkuste se věc č {0}
DocType: Material Request,% Completed,% Dokončeno
,Invoiced Amount (Exculsive Tax),Fakturovaná částka (bez daně)
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +59,Account head {0} created,Hlava účtu {0} vytvořil
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +148,Green,Zelená
DocType: Sales Order Item,Discount(%),Sleva (%)
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +57,Total Achieved,Celkem Dosažená
DocType: Employee,Place of Issue,Místo vydání
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +54,Contract,Smlouva
DocType: Report,Disabled,Vypnuto
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +523,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 +171,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +7,Agriculture,Zemědělství
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +559,Your Products or Services,Vaše Produkty nebo Služby
DocType: Mode of Payment,Mode of Payment,Způsob platby
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: Purchase Invoice Item,Purchase Order,Vydaná objednávka
DocType: Warehouse,Warehouse Contact Info,Sklad Kontaktní informace
sites/assets/js/form.min.js +180,Name is required,Jméno je vyžadováno
DocType: Purchase Invoice,Recurring Type,Opakující se Typ
DocType: Address,City/Town,Město / Město
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 +132,"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 +428,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
apps/erpnext/erpnext/stock/get_item_details.py +137,Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +41,Capital Equipments,Kapitálové Vybavení
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +31,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Ceny Pravidlo je nejprve vybrána na základě ""Použít na"" oblasti, které mohou být položky, položky skupiny nebo značky."
DocType: Hub Settings,Seller Website,Prodejce Website
apps/erpnext/erpnext/controllers/selling_controller.py +148,Total allocated percentage for sales team should be 100,Celkové přidělené procento prodejní tým by měl být 100
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +103,Production Order status is {0},Stav výrobní zakázka je {0}
DocType: Appraisal Goal,Goal,Cíl
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +572,For Supplier,Pro Dodavatele
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Nastavení typu účtu pomáhá při výběru tohoto účtu v transakcích.
DocType: Purchase Invoice,Grand Total (Company Currency),Celkový součet (Měna společnosti)
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Celkem Odchozí
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +42,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Tam může být pouze jeden Shipping Rule Podmínka s 0 nebo prázdnou hodnotu pro ""na hodnotu"""
DocType: DocType,Transaction,Transakce
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Poznámka: Tento Nákladové středisko je Group. Nelze vytvořit účetní zápisy proti skupinám.
apps/erpnext/erpnext/config/projects.py +43,Tools,Nástroje
DocType: Sales Taxes and Charges Template,Valid For Territories,Platí pro území
DocType: Item,Website Item Groups,Webové stránky skupiny položek
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +190,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 měny)
DocType: Applicable Territory,Applicable Territory,Použitelné Oblasti
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
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 +19,Email Digest:,E-mail Digest:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +429,BOM {0} does not belong to Item {1},BOM {0} nepatří k bodu {1}
DocType: Sales Partner,Target Distribution,Target Distribution
sites/assets/js/desk.min.js +536,Comments,Komentáře
DocType: Salary Slip,Bank Account No.,Bankovní účet č.
DocType: Naming Series,This is the number of the last created transaction with this prefix,To je číslo poslední vytvořené transakci s tímto prefixem
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +167,Valuation Rate required for Item {0},Ocenění Rate potřebný k bodu {0}
DocType: Quality Inspection Reading,Reading 8,Čtení 8
DocType: Sales Partner,Agent,Agent
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +74,"Total {0} for all items is zero, may you should change 'Distribute Charges Based On'","Celkem {0} pro všechny položky je nula, můžete měli změnit &quot;Distribuovat poplatků na základě&quot;"
DocType: Purchase Invoice,Taxes and Charges Calculation,Daně a poplatky výpočet
DocType: BOM Operation,Workstation,pracovna stanica
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +107,Hardware,Technické vybavení
DocType: Attendance,HR Manager,HR Manager
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +47,Privilege Leave,Privilege Leave
DocType: Purchase Invoice,Supplier Invoice Date,Dodavatelské faktury Datum
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +169,You need to enable Shopping Cart,Musíte povolit Nákupní košík
sites/assets/js/form.min.js +197,No Data,No Data
DocType: Appraisal Template Goal,Appraisal Template Goal,Posouzení Template Goal
DocType: Salary Slip,Earning,Získávání
DocType: Purchase Taxes and Charges,Add or Deduct,Přidat nebo Odečíst
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +75,Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +134,Against Journal Entry {0} is already adjusted against some other voucher,Proti věstníku Entry {0} je již nastavena proti jiným poukaz
DocType: Backup Manager,Files Folder ID,ID složeky souborů
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +58,Total Order Value,Celková hodnota objednávky
apps/erpnext/erpnext/stock/doctype/item/item.py +196,Item Variants {0} deleted,Bod Varianty {0} vypouští
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +38,Food,Jídlo
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Stárnutí Rozsah 3
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +127,You can make a time log only against a submitted production order,Můžete udělat časový záznam pouze proti předložené výrobní objednávce
DocType: Maintenance Schedule Item,No of Visits,Počet návštěv
DocType: Cost Center,old_parent,old_parent
apps/erpnext/erpnext/config/support.py +33,"Newsletters to contacts, leads.","Zpravodaje ke kontaktům, vede."
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Součet bodů za všech cílů by mělo být 100. Je {0}
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +368,Operations cannot be left blank.,Operace nemůže být prázdné.
,Delivered Items To Be Billed,Dodávaných výrobků fakturovaných
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +61,Warehouse cannot be changed for Serial No.,Warehouse nemůže být změněn pro Serial No.
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +99,Status updated to {0},Status aktualizován na {0}
DocType: DocField,Description,Popis
DocType: Authorization Rule,Average Discount,Průměrná sleva
DocType: Backup Manager,Backup Manager,Správce zálohování
DocType: Letter Head,Is Default,Je Výchozí
DocType: Address,Utilities,Utilities
DocType: Purchase Invoice Item,Accounting,Účetnictví
DocType: Features Setup,Features Setup,Nastavení Funkcí
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,View Offer Letter,View Nabídka Dopis
DocType: Sales BOM,Sales BOM,Sales BOM
DocType: Communication,Communication,Komunikace
DocType: Item,Is Service Item,Je Service Item
DocType: Activity Cost,Projects,Projekty
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +30,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}
DocType: BOM Operation,Operation Description,Operace Popis
DocType: Item,Will also apply to variants,Bude se vztahovat i na varianty
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +30,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Nelze měnit Fiskální rok Datum zahájení a fiskální rok datum ukončení, jakmile fiskální rok se uloží."
DocType: Quotation,Shopping Cart,Nákupní vozík
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Avg Daily Odchozí
DocType: Pricing Rule,Campaign,Kampaň
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +29,Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto"""
DocType: Sales Invoice,Sales BOM Help,Sales BOM Help
DocType: Purchase Invoice,Contact Person,Kontaktní osoba
apps/erpnext/erpnext/projects/doctype/task/task.py +34,'Expected Start Date' can not be greater than 'Expected End Date',"""Očekávaný Datum Začátku"" nemůže být větší než ""Očekávanou Datum Konce"""
DocType: Holiday List,Holidays,Prázdniny
DocType: Sales Order Item,Planned Quantity,Plánované Množství
DocType: Purchase Invoice Item,Item Tax Amount,Částka Daně Položky
DocType: Supplier Quotation,Get Terms and Conditions,Získejte Smluvní podmínky
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 +391,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 +165,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +16,From Datetime,Od datetime
DocType: Email Digest,For Company,Pro Společnost
apps/erpnext/erpnext/config/support.py +38,Communication log.,Komunikační protokol.
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +66,Buying Amount,Nákup Částka
DocType: Sales Invoice,Shipping Address Name,Přepravní Adresa Název
apps/erpnext/erpnext/accounts/doctype/account/account.js +50,Chart of Accounts,Diagram účtů
DocType: Material Request,Terms and Conditions Content,Podmínky Content
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +506,cannot be greater than 100,nemůže být větší než 100
DocType: Purchase Receipt Item,Discount  %,Sleva%
apps/erpnext/erpnext/stock/doctype/item/item.py +473,Item {0} is not a stock Item,Položka {0} není skladem
DocType: Maintenance Visit,Unscheduled,Neplánovaná
DocType: Employee,Owned,Vlastník
DocType: Pricing Rule,"Higher the number, higher the priority","Vyšší číslo, vyšší priorita"
,Purchase Invoice Trends,Trendy přijatách faktur
DocType: Employee,Better Prospects,Lepší vyhlídky
DocType: Appraisal,Goals,Cíle
DocType: Warranty Claim,Warranty / AMC Status,Záruka / AMC Status
,Accounts Browser,Účty Browser
DocType: GL Entry,GL Entry,Vstup GL
DocType: HR Settings,Employee Settings,Nastavení zaměstnanců
,Batch-Wise Balance History,Batch-Wise Balance History
DocType: Email Digest,To Do List,Do List
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +58,Apprentice,Učeň
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +94,Negative Quantity is not allowed,Negativní množství není dovoleno
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Tax detail tabulka staženy z položky pána jako řetězec a uložené v této oblasti.
 Používá se daní a poplatků"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +60,Lancing,Lancing
apps/erpnext/erpnext/hr/doctype/employee/employee.py +147,Employee cannot report to himself.,Zaměstnanec nemůže odpovídat sám sobě.
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","V případě, že účet je zamrzlý, položky mohou omezeným uživatelům."
DocType: Job Opening,"Job profile, qualifications required etc.","Profil Job, požadované kvalifikace atd."
DocType: Journal Entry Account,Account Balance,Zůstatek na účtu
DocType: Rename Tool,Type of document to rename.,Typ dokumentu přejmenovat.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +578,We buy this Item,Vykupujeme tuto položku
DocType: Address,Billing,Fakturace
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +76,Flanging,Obrubování
DocType: Bulk Email,Not Sent,Neodesláno
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +72,Explosive forming,Výbušné tváření
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 +41,Scheduled to send to {0} recipients,Plánované poslat na {0} příjemci
DocType: Quality Inspection,Readings,Čtení
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +571,Sub Assemblies,Podsestavy
DocType: Shipping Rule Condition,To Value,Chcete-li hodnota
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +159,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
DocType: Packing Slip,Packing Slip,Balení Slip
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Office Rent,Pronájem kanceláře
apps/erpnext/erpnext/config/setup.py +80,Setup SMS gateway settings,Nastavení Nastavení SMS brána
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +59,Import Failed!,Import se nezdařil!
sites/assets/js/erpnext.min.js +19,No address added yet.,Žádná adresa přidán dosud.
DocType: Workstation Working Hour,Workstation Working Hour,Pracovní stanice Pracovní Hour
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +78,Analyst,Analytik
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +191,Row {0}: Allocated amount {1} must be less than or equals to JV amount {2},"Řádek {0}: přidělené množství {1}, musí být menší než nebo se rovná hodnotě JV {2}"
DocType: Item,Inventory,Inventář
DocType: Item,Sales Details,Prodejní Podrobnosti
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +148,Pinning,Připne
DocType: Opportunity,With Items,S položkami
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +35,In Qty,V Množství
DocType: Notification Control,Expense Claim Rejected,Uhrazení výdajů zamítnuto
DocType: Sales Invoice,"The date on which next invoice will be generated. It is generated on submit.
","Datum, kdy bude vygenerován příští faktury. To je generován na odeslat."
DocType: Item Attribute,Item Attribute,Položka Atribut
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +100,Government,Vláda
DocType: Item,Re-order,Re objednávku
DocType: Company,Services,Služby
apps/erpnext/erpnext/accounts/report/financial_statements.py +149,Total ({0}),Celkem ({0})
DocType: Cost Center,Parent Cost Center,Nadřazené Nákladové středisko
DocType: Sales Invoice,Source,Zdroj
DocType: Leave Type,Is Leave Without Pay,Je odejít bez Pay
DocType: Purchase Order Item,"If Supplier Part Number exists for given Item, it gets stored here","Pokud dodavatel Kód existuje pro danou položku, dostane uloženy zde"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +175,No records found in the Payment table,Nalezené v tabulce platby Žádné záznamy
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +403,Financial Year Start Date,Finanční rok Datum zahájení
DocType: Employee External Work History,Total Experience,Celková zkušenost
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +99,Countersinking,Zahlubování
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packing Slip(s) cancelled,Balení Slip (y) zrušeno
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +96,Freight and Forwarding Charges,Nákladní a Spediční Poplatky
DocType: Material Request Item,Sales Order No,Prodejní objednávky No
DocType: Item Group,Item Group Name,Položka Název skupiny
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +47,Taken,Zaujatý
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +63,Transfer Materials for Manufacture,Přenos Materiály pro výrobu
DocType: Pricing Rule,For Price List,Pro Ceník
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +26,Executive Search,Executive Search
apps/erpnext/erpnext/stock/stock_ledger.py +385,"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.","Cena při platbě za položku: {0} nebyl nalezen, který je povinen si účetní položka (náklady). Prosím, uveďte zboží Cena podle seznamu kupní cenou."
DocType: Maintenance Schedule,Schedules,Plány
DocType: Purchase Invoice Item,Net Amount,Čistá částka
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail No
DocType: Period Closing Voucher,CoA Help,CoA Help
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +533,Error: {0} > {1},Chyba: {0}> {1}
apps/erpnext/erpnext/accounts/doctype/account/account.js +8,Please create new account from Chart of Accounts.,"Prosím, vytvořte nový účet z grafu účtů."
DocType: Maintenance Visit,Maintenance Visit,Maintenance Visit
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +49,Customer > Customer Group > Territory,Zákazník> Zákazník Group> Territory
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,K dispozici šarže Množství ve skladu
DocType: Time Log Batch Detail,Time Log Batch Detail,Time Log Batch Detail
DocType: Workflow State,Tasks,úkoly
DocType: Landed Cost Voucher,Landed Cost Help,Přistálo Náklady Help
DocType: Event,Tuesday,Úterý
DocType: Leave Block List,Block Holidays on important days.,Blokové Dovolená na významných dnů.
,Accounts Receivable Summary,Pohledávky Shrnutí
apps/erpnext/erpnext/hr/doctype/employee/employee.py +178,Please set User ID field in an Employee record to set Employee Role,Prosím nastavte uživatelské ID pole v záznamu zaměstnanců nastavit role zaměstnance
DocType: UOM,UOM Name,UOM Name
DocType: Top Bar Item,Target,Cíl
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +33,Contribution Amount,Výše příspěvku
DocType: Sales Invoice,Shipping Address,Shipping Address
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,"Tento nástroj vám pomůže aktualizovat nebo opravit množství a ocenění zásob v systému. To se obvykle používá k synchronizaci hodnot systému a to, co ve skutečnosti existuje ve vašich skladech."
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"Ve slovech budou viditelné, jakmile uložíte doručení poznámku."
apps/erpnext/erpnext/config/stock.py +120,Brand master.,Master Značky
DocType: ToDo,Due Date,Datum splatnosti
DocType: Sales Invoice Item,Brand Name,Jméno značky
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Box,Krabice
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +387,The Organization,Organizace
DocType: Monthly Distribution,Monthly Distribution,Měsíční Distribution
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +66,Receiver List is empty. Please create Receiver List,Přijímač Seznam je prázdný. Prosím vytvořte přijímače Seznam
DocType: Production Plan Sales Order,Production Plan Sales Order,Výrobní program prodejní objednávky
DocType: Sales Partner,Sales Partner Target,Sales Partner Target
DocType: Pricing Rule,Pricing Rule,Ceny Pravidlo
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +57,Notching,Vystřihování
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +44,Reserved warehouse required for stock item {0},Vyhrazeno sklad potřebný pro živočišnou položku {0}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankovní účty
,Bank Reconciliation Statement,Bank Odsouhlasení prohlášení
DocType: Address,Lead Name,Olovo Name
,POS,POS
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +14,{0} must appear only once,{0} musí být uvedeny pouze jednou
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +371,Not allowed to tranfer more {0} than {1} against Purchase Order {2},"Není povoleno, aby transfer více {0} než {1} proti Objednávky {2}"
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +58,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 +579,Manufacturing Quantity is mandatory,Výrobní množství je povinné
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +41,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.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +7,Centrifugal casting,Odstředivé lití
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +118,Magnetic field-assisted finishing,Magnetické pole-assisted dokončování
DocType: Company,Default Holiday List,Výchozí Holiday Seznam
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +227,Task is Mandatory if Time Log is against a project,"Úkol je povinné, pokud Time Log je proti projektu"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +165,Stock Liabilities,Stock Závazky
DocType: Purchase Receipt,Supplier Warehouse,Dodavatel Warehouse
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
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/crm/doctype/lead/lead.js +34,Make Quotation,Značka Citace
DocType: Dependent Task,Dependent Task,Závislý Task
apps/erpnext/erpnext/stock/doctype/item/item.py +291,Conversion factor for default Unit of Measure must be 1 in row {0},"Konverzní faktor pro výchozí měrnou jednotku, musí být 1 v řádku {0}"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +193,You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,"Nelze zadat i dodací list č a prodejní faktury č Prosím, zadejte jednu."
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +142,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.,Zkuste plánování operací pro X dní předem.
DocType: HR Settings,Stop Birthday Reminders,Zastavit připomenutí narozenin
DocType: SMS Center,Receiver List,Přijímač Seznam
DocType: Payment Tool Detail,Payment Amount,Částka platby
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Spotřebovaném množství
DocType: Salary Structure Deduction,Salary Structure Deduction,Plat Struktura Odpočet
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +157,Selective laser sintering,Selektivní laserové spékání
apps/erpnext/erpnext/stock/doctype/item/item.py +286,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/frappe/frappe/core/page/data_import_tool/data_import_tool.js +74,Import Successful!,Import byl úspěšný!
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Náklady na vydaných položek
DocType: Email Digest,Expenses Booked,Náklady rezervováno
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +168,Quantity must not be more than {0},Množství nesmí být větší než {0}
DocType: Quotation Item,Quotation Item,Položka Nabídky
DocType: Account,Account Name,Název účtu
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +34,From Date cannot be greater than To Date,Datum OD nemůže být vetší než datum DO
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +209,Serial No {0} quantity {1} cannot be a fraction,Pořadové číslo {0} {1} množství nemůže být zlomek
apps/erpnext/erpnext/config/buying.py +59,Supplier Type master.,Dodavatel Type master.
DocType: Purchase Order Item,Supplier Part Number,Dodavatel Číslo dílu
apps/frappe/frappe/core/page/permission_manager/permission_manager.js +372,Add,Přidat
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Delivery Note,Vehicle Dispatch Date,Vozidlo Dispatch Datum
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +56,Task is mandatory if Expense Claim is against a Project,"Úkol je povinné, pokud Náklady Reklamace je proti projektu"
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +196,Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena
DocType: Company,Default Payable Account,Výchozí Splatnost účtu
DocType: Party Type,Contacts,Kontakty
apps/erpnext/erpnext/config/website.py +13,"Settings for online shopping cart such as shipping rules, price list etc.","Nastavení pro on-line nákupního košíku, jako jsou pravidla dopravu, ceník atd"
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +601,Setup Complete,Setup Complete
apps/erpnext/erpnext/controllers/website_list_for_contact.py +48,{0}% Billed,{0}% Účtovaný
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +33,Reserved Qty,Reserved Množství
DocType: Party Account,Party Account,Party účtu
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +69,Human Resources,Lidské zdroje
DocType: Lead,Upper Income,Horní příjmů
apps/erpnext/erpnext/support/doctype/issue/issue.py +52,My Issues,Moje problémy
DocType: BOM Item,BOM Item,BOM Item
DocType: Appraisal,For Employee,Pro zaměstnance
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +188,Row {0}: Payment amount can not be negative,Row {0}: Částka platby nemůže být záporný
DocType: Expense Claim,Total Amount Reimbursed,Celkové částky proplacené
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +151,Press fitting,Tisková kování
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +60,Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
DocType: Party Type,Default Price List,Výchozí Ceník
DocType: Journal Entry,User Remark will be added to Auto Remark,Uživatel Poznámka budou přidány do Auto Poznámka
DocType: Payment Reconciliation,Payments,Platby
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +23,Hot isostatic pressing,Izostatické lisování
DocType: ToDo,Medium,Střední
DocType: Budget Detail,Budget Allocated,Přidělený Rozpočet
,Customer Credit Balance,Zákazník Credit Balance
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',"Zákazník požadoval pro 'Customerwise sleva """
apps/erpnext/erpnext/config/accounts.py +53,Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
DocType: Quotation,Term Details,Termín Podrobnosti
DocType: Manufacturing Settings,Capacity Planning For (Days),Plánování kapacit Pro (dny)
DocType: Warranty Claim,Warranty Claim,Záruční reklamace
,Lead Details,Olověné Podrobnosti
DocType: Authorization Rule,Approving User,Schvalování Uživatel
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +36,Forging,Kování
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +125,Plating,Pokovování
DocType: Purchase Invoice,End date of current invoice's period,Datum ukončení doby aktuální faktury je
DocType: Pricing Rule,Applicable For,Použitelné pro
DocType: Bank Reconciliation,From Date,Od data
DocType: Backup Manager,Validate,Potvrdit
DocType: Maintenance Visit,Partially Completed,Částečně Dokončeno
DocType: Sales Invoice,Packed Items,Zabalené položky
apps/erpnext/erpnext/config/support.py +18,Warranty Claim against Serial No.,Reklamační proti sériového čísla
DocType: BOM Replace Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM","Nahradit konkrétní kusovník ve všech ostatních kusovníky, kde se používá. To nahradí původní odkaz kusovníku, aktualizujte náklady a regenerovat ""BOM explozi položku"" tabulku podle nového BOM"
DocType: Shopping Cart Settings,Enable Shopping Cart,Povolit Nákupní košík
DocType: Employee,Permanent Address,Trvalé bydliště
apps/erpnext/erpnext/stock/get_item_details.py +123,Item {0} must be a Service Item.,Položka {0} musí být služba položky.
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +158,Please select item code,"Prosím, vyberte položku kód"
DocType: Salary Structure Deduction,Reduce Deduction for Leave Without Pay (LWP),Snížit Odpočet o dovolenou bez nároku na odměnu (LWP)
DocType: Territory,Territory Manager,Oblastní manažer
DocType: Selling Settings,Selling Settings,Prodejní Nastavení
apps/erpnext/erpnext/stock/doctype/item/item.py +155,Item cannot be a variant of a variant,Položka nemůže být varianta varianty
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +38,Online Auctions,Aukce online
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +89,Please specify either Quantity or Valuation Rate or both,"Uveďte prosím buď Množství nebo ocenění Cena, nebo obojí"
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +36,"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 +208,"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
DocType: Journal Entry,View Details,Zobrazit podrobnosti
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 +160,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 +334,Warehouse required at Row No {0},Warehouse vyžadováno při Row No {0}
DocType: Employee,Date Of Retirement,Datum odchodu do důchodu
DocType: Upload Attendance,Get Template,Získat šablonu
DocType: Address,Postal,Poštovní
DocType: Email Digest,Total amount of invoices sent to the customer during the digest period,Celková částka faktury poslal k zákazníkovi v období digest
DocType: Item,Weightage,Weightage
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +158,Mining,Hornictví
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +16,Resin casting,Resin lití
apps/erpnext/erpnext/selling/doctype/customer/customer.py +79,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Zákaznická Skupina existuje se stejným názvem, prosím změnit název zákazníka nebo přejmenujte skupinu zákazníků"
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/setup/page/setup_wizard/setup_wizard.js +570,Products,Výrobky
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +41,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: Lead,Next Contact By,Další Kontakt By
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +218,Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +85,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} nelze smazat, protože existuje množství k položce {1}"
DocType: Quotation,Order Type,Typ objednávky
DocType: Purchase Invoice,Notification Email Address,Oznámení e-mailová adresa
DocType: Payment Tool,Find Invoices to Match,Najít faktury zápas
,Item-wise Sales Register,Item-moudrý Sales Register
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +397,"e.g. ""XYZ National Bank""","např ""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/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +57,Total Target,Celkem Target
DocType: Job Applicant,Applicant for a Job,Žadatel o zaměstnání
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +178,No Production Orders created,Žádné výrobní zakázky vytvořené
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +131,Salary Slip of employee {0} already created for this month,Plat Slip of zaměstnance {0} již vytvořili pro tento měsíc
DocType: Stock Reconciliation,Reconciliation JSON,Odsouhlasení JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Příliš mnoho sloupců. Export zprávu a vytiskněte jej pomocí aplikace tabulky.
DocType: Sales Invoice Item,Batch No,Č. šarže
apps/erpnext/erpnext/setup/doctype/company/company.py +142,Main,Hlavní
DocType: DocPerm,Delete,Smazat
apps/erpnext/erpnext/stock/doctype/item/item_list.js +11,Variant,Varianta
sites/assets/js/desk.min.js +836,New {0},Nový: {0}
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 +154,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 +308,Default BOM ({0}) must be active for this item or its template,Výchozí BOM ({0}) musí být aktivní pro tuto položku nebo jeho šablony
DocType: Employee,Leave Encashed?,Ponechte zpeněžení?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +31,Opportunity From field is mandatory,Opportunity Ze hřiště je povinné
DocType: Sales Invoice,Considered as an Opening Balance,Považována za počáteční zůstatek
DocType: Item,Variants,Varianty
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +468,Make Purchase Order,Proveďte objednávky
DocType: SMS Center,Send To,Odeslat
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +111,There is not enough leave balance for Leave Type {0},Není dost bilance dovolenou na vstup typ {0}
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
DocType: Stock Reconciliation,Stock Reconciliation,Reklamní Odsouhlasení
DocType: Territory,Territory Name,Území Name
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +143,Work-in-Progress Warehouse is required before Submit,Work-in-Progress sklad je zapotřebí před Odeslat
apps/erpnext/erpnext/config/hr.py +43,Applicant for a Job.,Žadatel o zaměstnání.
DocType: Sales Invoice Item,Warehouse and Reference,Sklad a reference
DocType: Supplier,Statutory info and other general information about your Supplier,Statutární info a další obecné informace o váš dodavatel
DocType: Country,Country,Země
apps/erpnext/erpnext/shopping_cart/utils.py +48,Addresses,Adresy
DocType: Communication,Received,Přijato
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +156,Against Journal Entry {0} does not have any unmatched {1} entry,Proti věstníku Vstup {0} nemá bezkonkurenční {1} vstupu
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +216,Duplicate Serial No entered for Item {0},Duplicitní Pořadové číslo vstoupil k bodu {0}
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Podmínka pro pravidla dopravy
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +201,"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Název nového účtu. Poznámka: Prosím, vytvářet účty pro zákazníky a dodavatele, které se automaticky vytvoří z zákazníkem a dodavatelem master"
DocType: DocField,Attach Image,Připojit obrázek
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnost tohoto balíčku. (Automaticky vypočítá jako součet čisté váhy položek)
DocType: Stock Reconciliation Item,Leave blank if no change,"Ponechte prázdné, pokud žádná změna"
apps/erpnext/erpnext/config/manufacturing.py +24,Time Logs for manufacturing.,Čas Protokoly pro výrobu.
DocType: Item,Apply Warehouse-wise Reorder Level,Použít Skladovací-moudrý Seřadit sezn Level
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +426,BOM {0} must be submitted,BOM {0} musí být předloženy
DocType: Authorization Control,Authorization Control,Autorizace Control
apps/erpnext/erpnext/config/projects.py +23,Time Log for tasks.,Time Log pro úkoly.
DocType: Production Order Operation,Actual Time and Cost,Skutečný Čas a Náklady
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +52,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materiál Žádost maximálně {0} lze k bodu {1} na odběratele {2}
DocType: Employee,Salutation,Oslovení
DocType: Offer Letter,Rejected,Zamítnuto
DocType: Pricing Rule,Brand,Značka
DocType: Item,Will also apply for variants,Bude platit i pro varianty
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +609,% Delivered,% Dodáno
apps/erpnext/erpnext/config/selling.py +148,Bundle items at time of sale.,Bundle položky v okamžiku prodeje.
DocType: Sales Order Item,Actual Qty,Skutečné Množství
DocType: Quality Inspection Reading,Reading 10,Čtení 10
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +560,"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/setup/page/setup_wizard/install_fixtures.py +82,Associate,Spolupracovník
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +46,Item {0} is not a serialized Item,Položka {0} není serializovat položky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +573,"For 'Sales BOM' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pro ""Sales BOM"" předměty, sklad, bude Serial No a Batch No považují z ""Obsah balení"" tabulky. Pokud Warehouse a Batch No jsou stejné u všech balení předměty pro každého ""Prodej BOM"" položky, tyto hodnoty mohou být zapsány do hlavní tabulky položky, hodnoty se budou zkopírovány do ""Obsah balení"" tabulky."
DocType: SMS Center,Create Receiver List,Vytvořit přijímače seznam
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +5,Expired,Vypršela
DocType: Packing Slip,To Package No.,Balit No.
DocType: DocType,System,Systém
DocType: Warranty Claim,Issue Date,Datum vydání
DocType: Activity Cost,Activity Cost,Náklady Aktivita
DocType: Purchase Receipt Item Supplied,Consumed Qty,Spotřeba Množství
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +51,Telecommunications,Telekomunikace
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),"Označuje, že balíček je součástí této dodávky (Pouze návrhu)"
DocType: Payment Tool,Make Payment Entry,Učinit vstup platby
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +119,Quantity for Item {0} must be less than {1},Množství k bodu {0} musí být menší než {1}
DocType: Backup Manager,Never,Nikdy
,Sales Invoice Trends,Prodejní faktury Trendy
DocType: Leave Application,Apply / Approve Leaves,Použít / Schválit listy
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +90,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Se může vztahovat řádku, pouze pokud typ poplatku je ""On předchozí řady Částka"" nebo ""předchozí řady Total"""
DocType: Item,Allowance Percent,Allowance Procento
DocType: SMS Settings,Message Parameter,Parametr zpráv
DocType: Serial No,Delivery Document No,Dodávka dokument č
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Získat položky z Příjmového listu
DocType: Serial No,Creation Date,Datum vytvoření
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +34,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,Dodavatel Nabídka Položka
apps/erpnext/erpnext/hr/doctype/employee/employee.js +27,Make Salary Structure,Proveďte platovou strukturu
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +53,Shearing,Stříhání
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."
apps/erpnext/erpnext/controllers/recurring_document.py +164,Period From and Period To dates mandatory for recurring %s,"Období od a období, na termíny povinných opakujících% s"
DocType: Journal Entry Account,Against Expense Claim,Proti Expense nároku
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +165,Packaging and labeling,Balení a označování
DocType: Monthly Distribution,Name of the Monthly Distribution,Název měsíční výplatou
DocType: Sales Person,Parent Sales Person,Parent obchodník
apps/erpnext/erpnext/setup/utils.py +14,Please specify Default Currency in Company Master and Global Defaults,"Uveďte prosím výchozí měnu, ve společnosti Master and Global výchozí"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +221,"Payment against {0} {1} cannot be greater \
					than Outstanding Amount {2}","Platba na {0} {1} nemůže být větší \
 než dlužná částka {2}"
DocType: Backup Manager,Dropbox Access Secret,Dropbox Access Secret
DocType: Purchase Invoice,Recurring Invoice,Opakující se faktury
DocType: Item,Net Weight of each Item,Hmotnost každé položky
DocType: Supplier,Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
DocType: Budget Detail,Fiscal Year,Fiskální rok
DocType: Cost Center,Budget,Rozpočet
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +50,Achieved,Dosažená
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +65,Territory / Customer,Territory / Customer
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +502,e.g. 5,např. 5
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +195,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Row {0}: Přidělená částka {1} musí být menší než nebo se rovná fakturovat dlužné částky {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,"Ve slovech budou viditelné, jakmile uložíte prodejní faktury."
DocType: Item,Is Sales Item,Je Sales Item
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Položka Group Tree
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +70,Item {0} is not setup for Serial Nos. Check Item master,"Položka {0} není nastavení pro Serial č. Zkontrolujte, zda master položku"
DocType: Maintenance Visit,Maintenance Time,Údržba Time
,Amount to Deliver,"Částka, která má dodávat"
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +568,A Product or Service,Produkt nebo Služba
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +139,There were errors.,Byly tam chyby.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +100,Tapping,Výčepní
DocType: Naming Series,Current Value,Current Value
apps/erpnext/erpnext/stock/doctype/item/item.py +145,Item Template cannot have stock and varaiants. Please remove stock from warehouses {0},"Položka Šablona nemůže mít zásoby a varaiants. Prosím, odstraňte zásoby ze skladů {0}"
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +176,{0} created,{0} vytvořil
DocType: Journal Entry Account,Against Sales Order,Proti přijaté objednávce
,Serial No Status,Serial No Status
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +502,Item table can not be blank,Tabulka Položka nemůže být prázdný
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +148,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Řádek {0}: Pro nastavení {1} periodicita, rozdíl mezi z a aktuální \
 musí být větší než nebo rovno {2}"
DocType: Pricing Rule,Selling,Prodejní
DocType: Employee,Salary Information,Vyjednávání o platu
DocType: Sales Person,Name and Employee ID,Jméno a ID zaměstnance
apps/erpnext/erpnext/accounts/party.py +186,Due Date cannot be before Posting Date,Datum splatnosti nesmí být před odesláním Datum
DocType: Website Item Group,Website Item Group,Website Item Group
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +170,Duties and Taxes,Odvody a daně
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +275,Please enter Reference date,"Prosím, zadejte Referenční den"
DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabulka k bodu, který se zobrazí na webových stránkách"
DocType: Purchase Order Item Supplied,Supplied Qty,Dodávané Množství
DocType: Material Request Item,Material Request Item,Materiál Žádost o bod
apps/erpnext/erpnext/config/stock.py +103,Tree of Item Groups.,Strom skupiny položek.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +100,Cannot refer row number greater than or equal to current row number for this Charge type,Nelze odkazovat číslo řádku větší nebo rovnou aktuální číslo řádku pro tento typ Charge
,Item-wise Purchase History,Item-moudrý Historie nákupů
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +147,Red,Červená
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +237,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosím, klikněte na ""Generovat Schedule"", aby přinesla Pořadové číslo přidán k bodu {0}"
DocType: Account,Frozen,Zmražený
,Open Production Orders,Otevřené výrobní zakázky
DocType: Installation Note,Installation Time,Instalace Time
apps/erpnext/erpnext/setup/doctype/company/company.js +36,Delete all the Transactions for this Company,Odstraňte všechny transakce pro tuto společnost
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204,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
apps/erpnext/erpnext/config/stock.py +84,Change UOM for an Item.,Změna UOM za položku.
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 +256,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/setup/page/setup_wizard/setup_wizard.js +569,Group,Skupina
DocType: Task,Expected Time (in hours),Předpokládaná doba (v hodinách)
,Qty to Order,Množství k objednávce
DocType: Sales Order,PO No,PO No
apps/erpnext/erpnext/config/projects.py +51,Gantt chart of all tasks.,Ganttův diagram všech zadaných úkolů.
DocType: Appraisal,For Employee Name,Pro jméno zaměstnance
DocType: Holiday List,Clear Table,Clear Table
DocType: Features Setup,Brands,Značky
DocType: C-Form Invoice Detail,Invoice No,Faktura č
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +497,From Purchase Order,Z vydané objednávky
apps/erpnext/erpnext/accounts/party.py +139,Please select company first.,Vyberte společnost jako první.
DocType: Activity Cost,Costing Rate,Kalkulace Rate
DocType: Journal Entry Account,Against Journal Entry,Proti položka deníku
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/buying/page/purchase_analytics/purchase_analytics.js +137,Not Set,Není nastaveno
DocType: Communication,Date,Datum
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/setup/page/setup_wizard/setup_wizard.js +592,Sit tight while your system is being setup. This may take a few moments.,"Drž se, když váš systém je nastavení. To může trvat několik okamžiků."
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +46,{0} ({1}) must have role 'Expense Approver',"{0} ({1}), musí mít roli ""Schvalovatel výdajů"""
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,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
DocType: Delivery Note,Excise Page Number,Spotřební Číslo stránky
DocType: Employee,Personal Details,Osobní data
,Maintenance Schedules,Plány údržby
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +43,Embossing,Ražba
,Quotation Trends,Uvozovky Trendy
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +135,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 +243,Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
apps/erpnext/erpnext/stock/doctype/item/item.py +295,"As Production Order can be made for this item, it must be a stock item.","Jako výrobní objednávce lze provést za tuto položku, musí být skladem."
DocType: Shipping Rule Condition,Shipping Amount,Přepravní Částka
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +139,Joining,Spojování
DocType: Authorization Rule,Above Value,Výše uvedená hodnota
,Pending Amount,Čeká Částka
DocType: Purchase Invoice Item,Conversion Factor,Konverzní faktor
DocType: Serial No,Delivered,Dodává
apps/erpnext/erpnext/config/hr.py +160,Setup incoming server for jobs email id. (e.g. jobs@example.com),Nastavení příchozí server pro úlohy e-mailovou id. (Např jobs@example.com)
DocType: Purchase Invoice,The date on which recurring invoice will be stop,"Datum, kdy opakující se faktura bude zastaví"
DocType: Journal Entry,Accounts Receivable,Pohledávky
,Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics
DocType: Address Template,This format is used if country specific format is not found,"Tento formát se používá, když specifický formát země není nalezen"
DocType: Custom Field,Custom,Zvyk
DocType: Production Order,Use Multi-Level BOM,Použijte Multi-Level BOM
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +25,Injection molding,Vstřikování
DocType: Bank Reconciliation,Include Reconciled Entries,Zahrnout odsouhlasené zápisy
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 +253,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/frappe/frappe/config/setup.py +130,Printing,Tisk
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +107,Expense Claim is pending approval. Only the Expense Approver can update status.,Úhrada výdajů čeká na schválení. Pouze schalovatel výdajů může aktualizovat stav.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +99,The day(s) on which you are applying for leave are holiday. You need not apply for leave.,"Den (y), na které žádáte o dovolené jsou dovolenou. Potřebujete nevztahuje na dovolenou."
sites/assets/js/desk.min.js +684,and,a
DocType: Leave Block List Allow,Leave Block List Allow,Nechte Block List Povolit
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +49,Sports,Sportovní
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +61,Total Actual,Celkem Aktuální
DocType: Stock Entry,"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.","Získejte rychlost oceňování a dostupných zásob u zdroje / cílové skladu na uvedeném Datum zveřejnění čase. Pokud se na pokračování položku, stiskněte toto tlačítko po zadání sériového čísla."
apps/erpnext/erpnext/templates/includes/cart.js +288,Something went wrong.,Něco se pokazilo.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Unit,Jednotka
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_dropbox.py +129,Please set Dropbox access keys in your site config,"Prosím, nastavení přístupových klíčů Dropbox ve vašem webu config"
apps/erpnext/erpnext/stock/get_item_details.py +114,Please specify Company,"Uveďte prosím, firmu"
,Customer Acquisition and Loyalty,Zákazník Akvizice a loajality
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +103,From Time cannot be greater than To Time,"Čas od nemůže být větší, než čas do"
DocType: Purchase Receipt,Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek"
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +406,Your financial year ends on,Váš finanční rok končí
DocType: POS Setting,Price List,Ceník
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +20,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} je nyní výchozí fiskální rok. Prosím aktualizujte svůj prohlížeč aby se změny projevily.
apps/erpnext/erpnext/projects/doctype/project/project.js +41,Expense Claims,Nákladové Pohledávky
DocType: Email Digest,Support,Podpora
DocType: Authorization Rule,Approving Role,Schvalování roli
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +89,Please specify currency in Company,"Uveďte prosím měnu, ve společnosti"
DocType: Workstation,Wages per hour,Mzda za hodinu
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +43,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Sklad bilance v dávce {0} se zhorší {1} k bodu {2} ve skladu {3}
apps/erpnext/erpnext/config/setup.py +53,"Show / Hide features like Serial Nos, POS etc.","Zobrazit / skrýt funkce, jako pořadová čísla, POS atd"
DocType: Purchase Receipt,LR No,LR No
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +34,UOM Conversion factor is required in row {0},UOM Konverzní faktor je nutné v řadě {0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +51,Clearance date cannot be before check date in row {0},Datum vůle nemůže být před přihlášením dnem v řadě {0}
DocType: Salary Slip,Deduction,Dedukce
DocType: Address Template,Address Template,Šablona adresy
DocType: Territory,Classification of Customers by region,Rozdělení zákazníků podle krajů
DocType: Project,% Tasks Completed,% splněných úkolů
DocType: Project,Gross Margin,Hrubá marže
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +137,Please enter Production Item first,"Prosím, zadejte první výrobní položku"
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +76,disabled user,zakázané uživatelské
DocType: Opportunity,Quotation,Nabídka
DocType: Salary Slip,Total Deduction,Celkem Odpočet
apps/erpnext/erpnext/templates/includes/cart.js +99,Hey! Go ahead and add an address,Hey! Jděte do toho a přidejte adresu
DocType: Quotation,Maintenance User,Údržba uživatele
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +144,Cost Updated,Náklady Aktualizováno
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +764,Are you sure you want to UNSTOP,"Jste si jisti, že chcete ODZASTAVIT"
DocType: Employee,Date of Birth,Datum narození
DocType: Salary Manager,Salary Manager,Plat Správce
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +425,Item {0} has already been returned,Bod {0} již byla vrácena
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiskální rok ** představuje finanční rok. Veškeré účetní záznamy a další významné transakce jsou sledovány proti ** fiskální rok **.
DocType: Opportunity,Customer / Lead Address,Zákazník / Lead Address
DocType: Production Order Operation,Actual Operation Time,Aktuální Provozní doba
DocType: Authorization Rule,Applicable To (User),Vztahující se na (Uživatel)
DocType: Purchase Taxes and Charges,Deduct,Odečíst
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +165,Job Description,Popis Práce
DocType: Purchase Order Item,Qty as per Stock UOM,Množství podle Stock nerozpuštěných
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +34,Please select a valid csv file with data,Vyberte prosím platný CSV soubor s daty
DocType: Features Setup,To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,Chcete-li sledovat položky v oblasti prodeje a nákupu dokumenty šarže nos <br> <b> Preferovaná Industry: Chemikálie etc </ b>
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +91,Coating,Nátěr
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +121,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Speciální znaky kromě ""-"". """", ""#"", a ""/"" není povoleno v pojmenování řady"
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Mějte přehled o prodejních kampaní. Mějte přehled o Leads, citace, prodejní objednávky atd z kampaně, aby zjistily, návratnost investic. "
DocType: Expense Claim,Approver,Schvalovatel
,SO Qty,SO Množství
apps/erpnext/erpnext/accounts/doctype/account/account.py +127,"Stock entries exist against warehouse {0}, hence you cannot re-assign or modify Warehouse","Přírůstky zásob existují proti skladu {0}, a proto není možné přeřadit nebo upravit Warehouse"
DocType: Appraisal,Calculate Total Score,Vypočítat Celková skóre
DocType: Salary Slip Deduction,Depends on LWP,Závisí na LWP
DocType: Supplier Quotation,Manufacturing Manager,Výrobní ředitel
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +201,Serial No {0} is under warranty upto {1},Pořadové číslo {0} je v záruce aľ {1}
apps/erpnext/erpnext/config/stock.py +69,Split Delivery Note into packages.,Rozdělit dodací list do balíčků.
apps/erpnext/erpnext/shopping_cart/utils.py +46,Shipments,Zásilky
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +28,Dip molding,Dip lití
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +25,Time Log Status must be Submitted.,Time Log Status musí být předloženy.
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +591,Setting Up,Nastavení
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +90,Make Debit Note,Proveďte dluhu
DocType: Purchase Invoice,In Words (Company Currency),Slovy (měna společnosti)
DocType: Pricing Rule,Supplier,Dodavatel
DocType: C-Form,Quarter,Čtvrtletí
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +105,Miscellaneous Expenses,Různé výdaje
DocType: Global Defaults,Default Company,Výchozí Company
apps/erpnext/erpnext/controllers/stock_controller.py +165,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Náklady nebo Rozdíl účet je povinné k bodu {0} jako budou mít dopad na celkovou hodnotu zásob
apps/erpnext/erpnext/controllers/accounts_controller.py +285,"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","Nelze overbill k bodu {0} v řadě {1} více než {2}. Chcete-li povolit nadfakturace, prosím nastavte na skladě Nastavení"
DocType: Employee,Bank Name,Název banky
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +38,-Above,-Nad
apps/erpnext/erpnext/hr/doctype/employee/employee.py +131,User {0} is disabled,Uživatel {0} je zakázána
DocType: Leave Application,Total Leave Days,Celkový počet dnů dovolené
DocType: Email Digest,Note: Email will not be sent to disabled users,Poznámka: E-mail se nepodařilo odeslat pro zdravotně postižené uživatele
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 +305,{0} is mandatory for Item {1},{0} je povinná k položce {1}
DocType: Currency Exchange,From Currency,Od Měny
DocType: DocField,Name,Jméno
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +199,"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/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +61,Last Sales Order Date,Poslední prodejní objednávky Datum
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +90,Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Amounts not reflected in system,Částky nejsou zohledněny v systému
DocType: Purchase Invoice Item,Rate (Company Currency),Cena (Měna Společnosti)
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +40,Others,Ostatní
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +313,Production might not be able to finish by the Expected Delivery Date.,Výroba nemusí být schopen dokončit očekávanou Termín dodání.
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +19,Set as Stopped,Nastavit jako Zastaveno
DocType: POS Setting,Taxes and Charges,Daně a poplatky
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která se Nakupuje, Prodává nebo Skladuje."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +94,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
apps/frappe/frappe/core/doctype/doctype/boilerplate/controller_list.html +31,Completed,Dokončeno
DocType: Web Form,Select DocType,Zvolte DocType
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +103,Broaching,Protahování
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +11,Banking,Bankovnictví
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +48,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 +276,New Cost Center,Nové Nákladové Středisko
DocType: Bin,Ordered Quantity,Objednané množství
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +395,"e.g. ""Build tools for builders""","např ""Stavět nástroje pro stavitele """
DocType: Quality Inspection,In Process,V procesu
DocType: Authorization Rule,Itemwise Discount,Itemwise Sleva
DocType: Purchase Receipt,Detailed Breakup of the totals,Podrobný rozpadu součty
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +286,{0} against Sales Order {1},{0} proti Prodejní Objednávce {1}
DocType: Account,Fixed Asset,Základní Jmění
DocType: Time Log Batch,Total Billing Amount,Celková částka fakturace
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +47,Receivable Account,Pohledávky účtu
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +140,No Updates For,Žádné aktualizace pro
,Stock Balance,Reklamní Balance
DocType: Expense Claim Detail,Expense Claim Detail,Detail úhrady výdajů
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +259,Time Logs created:,Čas Záznamy vytvořil:
DocType: Company,If Yearly Budget Exceeded,Pokud Roční rozpočet překročen
DocType: Item,Weight UOM,Hmotnostní jedn.
DocType: Employee,Blood Group,Krevní Skupina
DocType: Purchase Invoice Item,Page Break,Zalomení stránky
DocType: Production Order Operation,Pending,Až do
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Uživatelé, kteří si vyhoví žádosti konkrétního zaměstnance volno"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +50,Office Equipments,Kancelářské Vybavení
DocType: Purchase Invoice Item,Qty,Množství
DocType: Fiscal Year,Companies,Společnosti
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +23,Electronics,Elektronika
DocType: Email Digest,"Balances of Accounts of type ""Bank"" or ""Cash""","Zůstatky na účtech typu ""banka"" nebo ""Cash"""
DocType: Shipping Rule,"Specify a list of Territories, for which, this Shipping Rule is valid","Zadejte seznam území, pro které tato Shipping pravidlo platí"
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Zvýšit Materiál vyžádání při stock dosáhne úrovně re-order
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +18,From Maintenance Schedule,Z plánu údržby
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +51,Full-time,Na plný úvazek
DocType: Company,Country Settings,Nastavení Země
DocType: Employee,Contact Details,Kontaktní údaje
DocType: C-Form,Received Date,Datum přijetí
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Pokud jste vytvořili standardní šablonu v prodeji daní a poplatků šablony, vyberte jednu a klikněte na tlačítko níže."
DocType: Backup Manager,Upload Backups to Google Drive,Nahrát zálohy na Disk Google
DocType: Stock Entry,Total Incoming Value,Celková hodnota Příchozí
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Nákupní Ceník
DocType: Offer Letter Term,Offer Term,Nabídka Term
DocType: Quality Inspection,Quality Manager,Manažer kvality
DocType: Job Applicant,Job Opening,Job Zahájení
DocType: Payment Reconciliation,Payment Reconciliation,Platba Odsouhlasení
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +164,Please select Incharge Person's name,"Prosím, vyberte incharge jméno osoby"
DocType: Delivery Note,Date on which lorry started from your warehouse,"Datum, kdy nákladní automobil začal ze svého skladu"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +50,Technology,Technologie
DocType: Purchase Order,Supplier (vendor) name as entered in supplier master,"Dodavatel (prodávající), název, jak je uvedena v dodavatelských master"
DocType: Offer Letter,Offer Letter,Nabídka Letter
apps/erpnext/erpnext/config/manufacturing.py +51,Generate Material Requests (MRP) and Production Orders.,Generování materiálu Požadavky (MRP) a výrobní zakázky.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68,Total Invoiced Amt,Celkové fakturované Amt
DocType: Time Log,To Time,Chcete-li čas
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +25,"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Chcete-li přidat podřízené uzly, prozkoumat stromu a klepněte na položku, pod kterou chcete přidat více uzlů."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +94,Credit To account must be a Payable account,Připsat na účet musí být Splatnost účet
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +236,BOM recursion: {0} cannot be parent or child of {2},BOM rekurze: {0} nemůže být rodič nebo dítě {2}
DocType: Production Order Operation,Completed Qty,Dokončené Množství
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +135,"For {0}, only debit accounts can be linked against another credit entry","Pro {0}, tak debetní účty mohou být spojeny proti jinému připsání"
apps/erpnext/erpnext/stock/get_item_details.py +236,Price List {0} is disabled,Ceník {0} je zakázána
DocType: Manufacturing Settings,Allow Overtime,Povolit Přesčasy
apps/erpnext/erpnext/controllers/selling_controller.py +247,Sales Order {0} is stopped,Prodejní objednávky {0} je zastaven
DocType: Email Digest,New Leads,Nové vede
DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuální ocenění Rate
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,"Advance paid against {0} {1} cannot be greater \
					than Grand Total {2}","Vyplacena záloha na {0} {1} nemůže být větší \
 než Celkový součet {2}"
DocType: Opportunity,Lost Reason,Ztracené Důvod
apps/erpnext/erpnext/config/accounts.py +68,Create Payment Entries against Orders or Invoices.,Vytvořte Platební záznamy proti objednávky nebo faktury.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +140,Welding,Svařování
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +18,New Stock UOM is required,Je zapotřebí nové Reklamní UOM
DocType: Quality Inspection,Sample Size,Velikost vzorku
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +418,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 +280,Further cost centers can be made under Groups but entries can be made against non-Groups,"Další nákladová střediska mohou být vyrobeny v rámci skupiny, ale položky mohou být provedeny proti non-skupin"
DocType: Project,External,Externí
DocType: Features Setup,Item Serial Nos,Položka sériových čísel
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +8,Not Received,Neobdržel
DocType: Branch,Branch,Větev
DocType: Sales Invoice,Customer (Receivable) Account,Customer (pohledávka) Account
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 +198,Serial No {0} not found,Pořadové číslo {0} nebyl nalezen
DocType: Shopping Cart Settings,Price Lists,Ceníky
DocType: Purchase Invoice,Considered as Opening Balance,Považován za počáteční zůstatek
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +513,Your Customers,Vaši Zákazníci
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +26,Compression molding,Lisování
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í
apps/erpnext/erpnext/config/setup.py +75,"Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest."
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +46,Item Code > Item Group > Brand,Kód položky> Položka Group> Brand
DocType: Appraisal Goal,Appraisal Goal,Posouzení Goal
DocType: Event,Friday,Pátek
DocType: Time Log,Costing Amount,Kalkulace Částka
DocType: Salary Manager,Submit Salary Slip,Odeslat výplatní pásce
DocType: Salary Structure,Monthly Earning & Deduction,Měsíčního výdělku a dedukce
apps/erpnext/erpnext/controllers/selling_controller.py +162,Maxiumm discount for Item {0} is {1}%,Maxiumm sleva na položky {0} {1}%
DocType: Supplier,Address & Contacts,Adresa a kontakty
DocType: SMS Log,Sender Name,Jméno odesílatele
DocType: Page,Title,Titulek
sites/assets/js/list.min.js +92,Customize,Přizpůsobit
DocType: POS Setting,[Select],[Vybrat]
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +28,Make Sales Invoice,Proveďte prodejní faktuře
DocType: Company,For Reference Only.,Pouze orientační.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,Invalid {0}: {1},Neplatný {0}: {1}
DocType: Sales Invoice Advance,Advance Amount,Záloha ve výši
DocType: Manufacturing Settings,Capacity Planning,Plánování kapacit
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +49,'From Date' is required,"""Datum od"" je povinné"
DocType: Journal Entry,Reference Number,Referenční číslo
DocType: Employee,Employment Details,Informace o zaměstnání
DocType: Employee,New Workplace,Nové pracoviště
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Nastavit jako Zavřeno
apps/erpnext/erpnext/stock/get_item_details.py +104,No Item with Barcode {0},No Položka s čárovým kódem {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Případ č nemůže být 0
DocType: Features Setup,If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,"Máte-li prodejní tým a prodej Partners (obchodních partnerů), které mohou být označeny a udržovat svůj příspěvek v prodejní činnosti"
DocType: Item,Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky
apps/erpnext/erpnext/setup/doctype/company/company.py +71,Stores,Obchody
DocType: Time Log,Projects Manager,Správce projektů
DocType: Serial No,Delivery Time,Dodací lhůta
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Stárnutí dle
DocType: Item,End of Life,Konec životnosti
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +41,Travel,Cestování
DocType: Leave Block List,Allow Users,Povolit uživatele
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +199,Operation is Mandatory,Provoz je Povinné
DocType: Purchase Order,Recurring,Opakující se
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Sledovat samostatné výnosy a náklady pro vertikál produktu nebo divizí.
DocType: Rename Tool,Rename Tool,Přejmenování
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +11,Update Cost,Aktualizace Cost
DocType: Item Reorder,Item Reorder,Položka Reorder
DocType: Address,Check to make primary address,Zaškrtněte pro vytvoření primární adresy
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +507,Transfer Material,Přenos materiálu
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Zadejte operací, provozní náklady a dávají jedinečnou operaci ne své operace."
DocType: Purchase Invoice,Price List Currency,Ceník Měna
DocType: Naming Series,User must always select,Uživatel musí vždy vybrat
DocType: Stock Settings,Allow Negative Stock,Povolit Negativní Sklad
DocType: Installation Note,Installation Note,Poznámka k instalaci
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +491,Add Taxes,Přidejte daně
,Financial Analytics,Finanční Analýza
DocType: Quality Inspection,Verified By,Verified By
DocType: Address,Subsidiary,Dceřiný
apps/erpnext/erpnext/setup/doctype/company/company.py +37,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nelze změnit výchozí měně společnosti, protože tam jsou stávající transakce. Transakce musí být zrušena, aby změnit výchozí měnu."
DocType: Quality Inspection,Purchase Receipt No,Číslo příjmky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Earnest Money
DocType: Salary Manager,Create Salary Slip,Vytvořit výplatní pásce
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +44,Expected balance as per bank,Očekávaný zůstatek podle banky
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +114,Buffing,Leštění
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 +383,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,Importovat e-maily z
DocType: Features Setup,After Sale Installations,Po prodeji instalací
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +233,{0} {1} is fully billed,{0} {1} je plně fakturováno
DocType: Workstation Working Hour,End Time,End Time
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky pro prodej nebo koupi.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +79,Group by Voucher,Seskupit podle Poukazu
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Povinné On
DocType: Sales Invoice,Mass Mailing,Hromadné emaily
DocType: Page,Standard,Standard
DocType: Rename Tool,File to Rename,Soubor přejmenovat
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +175,Purchse Order number required for Item {0},Purchse Objednací číslo potřebný k bodu {0}
apps/erpnext/erpnext/controllers/buying_controller.py +246,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +183,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí být zrušena před zrušením této prodejní objednávky
DocType: Email Digest,Payments Received,Přijaté platby
DocType: Cost Center,"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Definovat rozpočtu na tento nákladového střediska. Chcete-li nastavit rozpočtu akce, viz <a href = ""#!List / Company ""> Společnost Mistr </a>"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +138,Size,Velikost
DocType: Notification Control,Expense Claim Approved,Uhrazení výdajů schváleno
DocType: Email Digest,Calendar Events,Kalendář akcí
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +108,Pharmaceutical,Farmaceutické
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Náklady na zakoupené zboží
DocType: Selling Settings,Sales Order Required,Prodejní objednávky Povinné
apps/erpnext/erpnext/crm/doctype/lead/lead.js +30,Create Customer,Vytvořit zákazníka
DocType: Purchase Invoice,Credit To,Kredit:
DocType: Employee Education,Post Graduate,Postgraduální
DocType: Backup Manager,"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Poznámka: Zálohy a soubory nejsou odstraněny z Dropbox, budete muset odstranit ručně."
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Plán údržby Detail
DocType: Quality Inspection Reading,Reading 9,Čtení 9
DocType: Buying Settings,Buying Settings,Nákup Nastavení
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +121,Mass finishing,Mass dokončovací
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce
DocType: Upload Attendance,Attendance To Date,Účast na data
apps/erpnext/erpnext/config/selling.py +153,Setup incoming server for sales email id. (e.g. sales@example.com),Nastavení příchozí server pro prodej e-mailovou id. (Např sales@example.com)
DocType: Warranty Claim,Raised By,Vznesené
DocType: Payment Tool,Payment Account,Platební účet
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +725,Please specify Company to proceed,Uveďte prosím společnost pokračovat
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +14,Google Drive,Google Drive
sites/assets/js/list.min.js +22,Draft,Návrh
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +45,Compensatory Off,Vyrovnávací Off
DocType: Quality Inspection Reading,Accepted,Přijato
DocType: User,Female,Žena
apps/erpnext/erpnext/setup/doctype/company/company.js +19,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,"Ujistěte se, že opravdu chcete vymazat všechny transakce pro tuto společnost. Vaše kmenová data zůstanou, jak to je. Tuto akci nelze vrátit zpět."
DocType: Print Settings,Modern,Moderní
DocType: Communication,Replied,Odpovězeno
DocType: Payment Tool,Total Payment Amount,Celková Částka platby
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +136,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemůže být větší, než Plánované Množství ({2}), ve Výrobní Objednávce {3}"
DocType: Shipping Rule,Shipping Rule Label,Přepravní Pravidlo Label
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +212,Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
DocType: Newsletter,Test,Test
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +84,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,Pro Množství
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +162,Please enter Planned Qty for Item {0} at row {1},"Prosím, zadejte Plánované Množství k bodu {0} na řádku {1}"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +218,{0} {1} is not submitted,{0} {1} není odesláno
apps/erpnext/erpnext/config/stock.py +13,Requests for items.,Žádosti o položky.
DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Samostatná výroba objednávka bude vytvořena pro každého hotového dobrou položku.
DocType: Email Digest,New Communications,Nová komunikace
DocType: Purchase Invoice,Terms and Conditions1,Podmínky a podmínek1
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard_page.html +18,Complete Setup,Kompletní nastavení
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Účetní záznam zmrazeny až do tohoto data, nikdo nemůže dělat / upravit položku kromě role uvedeno níže."
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +124,Please save the document before generating maintenance schedule,"Prosím, uložit dokument před generováním plán údržby"
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Stav projektu
DocType: UOM,Check this to disallow fractions. (for Nos),"Zkontrolujte, zda to zakázat frakce. (U č)"
apps/erpnext/erpnext/config/crm.py +86,Newsletter Mailing List,Newsletter adresář
DocType: Delivery Note,Transporter Name,Přepravce Název
DocType: Contact,Enter department to which this Contact belongs,"Zadejte útvar, který tento kontaktní patří"
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Absent,Celkem Absent
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +716,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 +109,Unit of Measure,Měrná jednotka
DocType: Fiscal Year,Year End Date,Datum Konce Roku
DocType: Task Depends On,Task Depends On,Úkol je závislá na
DocType: Lead,Opportunity,Příležitost
DocType: Salary Structure Earning,Salary Structure Earning,Plat Struktura Zisk
,Completed Production Orders,Dokončené Výrobní zakázky
DocType: Operation,Default Workstation,Výchozí Workstation
DocType: Email Digest,Inventory & Support,Zásoby a podpora
DocType: Notification Control,Expense Claim Approved Message,Zpráva o schválení úhrady výdajů
DocType: Email Digest,How frequently?,Jak často?
DocType: Purchase Receipt,Get Current Stock,Získejte aktuální stav
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +619,Make Installation Note,Proveďte Instalace Poznámka
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +208,Maintenance start date can not be before delivery date for Serial No {0},Datum zahájení údržby nemůže být před datem dodání pro pořadové číslo {0}
DocType: Production Order,Actual End Date,Skutečné datum ukončení
DocType: Authorization Rule,Applicable To (Role),Vztahující se na (Role)
DocType: Stock Entry,Purpose,Účel
DocType: Item,Will also apply for variants unless overrridden,"Bude platit i pro varianty, pokud nebude přepsáno"
DocType: Purchase Invoice,Advances,Zálohy
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Schválení Uživatel nemůže být stejná jako uživatel pravidlo se vztahuje na
DocType: SMS Log,No of Requested SMS,Počet žádaným SMS
DocType: Campaign,Campaign-.####,Kampaň-.####
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +485,Make Invoice,Proveďte faktury
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +54,Piercing,Pronikavý
DocType: Customer,Your Customer's TAX registration numbers (if applicable) or any general information,DIČ Vašeho zákazníka (pokud má) nebo jakékoli obecné informace
apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributor / dealer / jednatel / partner / prodejce, který prodává produkty společnosti za provizi."
DocType: Customer Group,Has Child Node,Má děti Node
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,{0} against Purchase Order {1},{0} proti Nákupní Objednávce {1}
DocType: SMS Settings,"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Zadejte statické parametry url zde (Např odesílatel = ERPNext, username = ERPNext, password. = 1234 atd.),"
apps/erpnext/erpnext/setup/page/setup_wizard/default_website.py +26,This is an example website auto-generated from ERPNext,To je příklad webové stránky automaticky generované z ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Stárnutí Rozsah 1
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +109,Photochemical machining,Fotochemický obrábění
DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
10. Add or Deduct: Whether you want to add or deduct the tax.","Standardní daň šablona, ​​která může být použita pro všechny nákupních transakcí. Tato šablona může obsahovat seznam daňových hlav a také ostatní náklady hlavy jako ""doprava"", ""pojištění"", ""manipulace"" atd. 

 #### Poznámka: 

 daňovou sazbu, můžete definovat zde bude základní sazba daně pro všechny ** položky **. Pokud jsou položky ** **, které mají různé ceny, musí být přidány v ** Položka daních ** stůl v ** položky ** mistra.

 #### Popis sloupců 

 1. Výpočet Type: 
 - To může být na ** Čistý Total ** (což je součet základní částky).
 - ** Na předchozí řady Total / Částka ** (pro kumulativní daní a poplatků). Zvolíte-li tuto možnost, bude daň se použije jako procento z předchozí řady (v daňové tabulky) množství nebo celkem.
 - ** Aktuální ** (jak je uvedeno).
 2. Účet Hlava: kniha účtu, pod kterým se bude tato daň rezervovat 
 3. Nákladové středisko: V případě, že daň / poplatek je příjmem (jako poštovné) nebo nákladů je třeba rezervovat na nákladové středisko.
 4. Popis: Popis daně (které budou vytištěny v faktur / uvozovek).
 5. Rate: Sazba daně.
 6. Částka: Částka daně.
 7. Celkem: Kumulativní celková k tomuto bodu.
 8. Zadejte Row: Je-li na základě ""předchozí řady Total"" můžete zvolit číslo řádku, která bude přijata jako základ pro tento výpočet (výchozí je předchozí řádek).
 9. Zvažte daň či poplatek za: V této části můžete nastavit, zda daň / poplatek je pouze pro ocenění (není součástí celkem), nebo pouze pro celkem (není přidanou hodnotu do položky), nebo pro obojí.
 10. Přidat nebo odečítat: Ať už chcete přidat nebo odečíst daň."
DocType: Note,Note,Poznámka
DocType: Email Digest,New Material Requests,Nové žádosti Materiál
DocType: Purchase Receipt Item,Recd Quantity,Recd Množství
DocType: Email Account,Email Ids,Email IDS
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +95,Cannot produce more Item {0} than Sales Order quantity {1},Nelze produkují více položku {0} než prodejní objednávky množství {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +23,Set as Unstopped,Nastavit jako nezastavěnou
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +440,Stock Entry {0} is not submitted,Sklad Entry {0} není předložena
DocType: Payment Reconciliation,Bank / Cash Account,Bank / Peněžní účet
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +43,This Leave Application is pending approval. Only the Leave Approver can update status.,To Leave Aplikace je čeká na schválení. Pouze Leave schvalovač aktualizovat stav.
DocType: Global Defaults,Hide Currency Symbol,Skrýt symbol měny
apps/erpnext/erpnext/config/accounts.py +154,"e.g. Bank, Cash, Credit Card","např. banka, hotovost, kreditní karty"
DocType: Journal Entry,Credit Note,Dobropis
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +206,Completed Qty cannot be more than {0} for operation {1},Dokončené množství nemůže být více než {0} pro provoz {1}
DocType: Features Setup,Quality,Kvalita
DocType: Contact Us Settings,Introduction,Úvod
DocType: Warranty Claim,Service Address,Servisní adresy
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Max 100 rows for Stock Reconciliation.,Max 100 řádky pro Stock smíření.
DocType: Stock Entry,Manufacture,Výroba
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Dodávka Vezměte prosím na vědomí první
DocType: Shopping Cart Taxes and Charges Master,Tax Master,Tax Mistr
DocType: Opportunity,Customer / Lead Name,Zákazník / Lead Name
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +61,Clearance Date not mentioned,Výprodej Datum není uvedeno
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +66,Production,Výroba
DocType: Item,Allow Production Order,Povolit výrobní objednávky
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +60,Row {0}:Start Date must be before End Date,"Row {0}: datum zahájení, musí být před koncem roku Datum"
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Total (ks)
DocType: Installation Note Item,Installed Qty,Instalované množství
DocType: Lead,Fax,Fax
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
sites/assets/js/list.min.js +26,Submitted,Vloženo
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/config/hr.py +100,Organization branch master.,Organizace větev master.
DocType: Purchase Invoice,Will be calculated automatically when you enter the details,"Bude vypočtena automaticky, když zadáte detaily"
DocType: Delivery Note,Transporter lorry number,Transporter číslo nákladní auto
DocType: Sales Order,Billing Status,Status Fakturace
DocType: Backup Manager,Backup Right Now,Zálohovat hned
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Utility Expenses,Utility Náklady
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +45,90-Above,90 Nad
DocType: Buying Settings,Default Buying Price List,Výchozí Nákup Ceník
DocType: Notification Control,Sales Order Message,Prodejní objednávky Message
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Nastavit jako výchozí hodnoty, jako je společnost, měna, aktuálním fiskálním roce, atd"
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js +20,Payment Type,Typ platby
DocType: Salary Manager,Select Employees,Vybrat Zaměstnanci
DocType: Bank Reconciliation,To Date,To Date
DocType: Opportunity,Potential Sales Deal,Potenciální prodej
sites/assets/js/form.min.js +286,Details,Podrobnosti
DocType: Purchase Invoice,Total Taxes and Charges,Celkem Daně a poplatky
DocType: Email Digest,Payments Made,Platby provedené
DocType: Employee,Emergency Contact,Kontakt v nouzi
DocType: Item,Quality Parameters,Parametry kvality
DocType: Target Detail,Target  Amount,Cílová částka
DocType: Shopping Cart Settings,Shopping Cart Settings,Nákupní košík Nastavení
DocType: Journal Entry,Accounting Entries,Účetní záznamy
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplicitní záznam. Zkontrolujte autorizační pravidlo {0}
DocType: Purchase Order,Ref SQ,Ref SQ
apps/erpnext/erpnext/config/manufacturing.py +56,Replace Item / BOM in all BOMs,Nahradit položky / kusovníky ve všech kusovníků
DocType: Purchase Order Item,Received Qty,Přijaté Množství
DocType: Stock Entry Detail,Serial No / Batch,Výrobní číslo / Batch
DocType: Sales BOM,Parent Item,Nadřazená položka
DocType: Account,Account Type,Typ účtu
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +222,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Plán údržby není generován pro všechny položky. Prosím, klikněte na ""Generovat Schedule"""
,To Produce,K výrobě
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +119,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pro řádek {0} v {1}. Chcete-li v rychlosti položku jsou {2}, řádky {3} musí být také zahrnuty"
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikace balíčku pro dodávky (pro tisk)
DocType: Bin,Reserved Quantity,Vyhrazeno Množství
DocType: Landed Cost Voucher,Purchase Receipt Items,Položky příjemky
DocType: Party Type,Parent Party Type,Parent Type Party
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +61,Cutting,Výstřižek
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +68,Flattening,Zploštění
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +27,Backups will be uploaded to,Zálohy budou nahrány na
DocType: Account,Income Account,Účet příjmů
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +21,Molding,Lití
DocType: Stock Reconciliation Item,Current Qty,Aktuální Množství
DocType: BOM Item,"See ""Rate Of Materials Based On"" in Costing Section","Viz ""Hodnotit materiálů na bázi"" v kapitole Costing"
DocType: Appraisal Goal,Key Responsibility Area,Key Odpovědnost Area
DocType: Item Reorder,Material Request Type,Materiál Typ požadavku
apps/frappe/frappe/desk/moduleview.py +61,Documents,Dokumenty
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +17,Ref,Ref
DocType: Cost Center,Cost Center,Nákladové středisko
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.js +48,Voucher #,Voucher #
DocType: Notification Control,Purchase Order Message,Zprávy vydané objenávky
DocType: Upload Attendance,Upload HTML,Nahrát HTML
apps/erpnext/erpnext/controllers/accounts_controller.py +323,"Total advance ({0}) against Order {1} cannot be greater \
				than the Grand Total ({2})","Celkem předem ({0}) na objednávku {1} nemůže být větší než \
 celkovém součtu ({2})"
DocType: Employee,Relieving Date,Uvolnění Datum
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +12,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Ceny Pravidlo je vyrobena přepsat Ceník / definovat slevy procenta, na základě určitých kritérií."
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Sklad je možné provést pouze prostřednictvím Burzy Entry / dodací list / doklad o zakoupení
DocType: Employee Education,Class / Percentage,Třída / Procento
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +87,Head of Marketing and Sales,Vedoucí marketingu a prodeje
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +31,Income Tax,Daň z příjmů
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +156,Laser engineered net shaping,Laser technicky čisté tvarování
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +15,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Je-li zvolena Ceny pravidlo je určen pro ""Cena"", přepíše ceníku. Ceny Pravidlo cena je konečná cena, a proto by měla být použita žádná další sleva. Proto, v transakcích, jako odběratele, objednávky atd, bude stažen v oboru ""sazbou"", spíše než poli ""Ceník sazby""."
apps/erpnext/erpnext/config/selling.py +158,Track Leads by Industry Type.,Trasa vede od průmyslu typu.
DocType: Item Supplier,Item Supplier,Položka Dodavatel
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +331,Please enter Item Code to get batch no,"Prosím, zadejte kód položky se dostat dávku no"
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +679,Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
DocType: Global Defaults,For automatic exchange rates go to jsonrates.com and signup for an API key,U automatických směnných kurzů jít do jsonrates.com a zaregistrovat pro klíč API
apps/erpnext/erpnext/config/selling.py +33,All Addresses.,Všechny adresy.
DocType: Company,Stock Settings,Stock Nastavení
DocType: User,Bio,Biografie
apps/erpnext/erpnext/accounts/doctype/account/account.py +166,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojení je možné pouze tehdy, pokud tyto vlastnosti jsou stejné v obou záznamech. Je Group, Root Type, Company"
apps/erpnext/erpnext/config/crm.py +62,Manage Customer Group Tree.,Správa zákazníků skupiny Tree.
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +278,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 +67,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 +47,Issues,Problémy
apps/erpnext/erpnext/utilities/__init__.py +24,Status must be one of {0},Stav musí být jedním z {0}
DocType: Sales Invoice,Debit To,Debetní K
DocType: Delivery Note,Required only for sample item.,Požadováno pouze pro položku vzorku.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Skutečné Množství Po transakci
,Pending SO Items For Purchase Request,"Do doby, než SO položky k nákupu Poptávka"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +143,Extra Large,Extra Velké
,Profit and Loss Statement,Výkaz zisků a ztrát
DocType: Bank Reconciliation Detail,Cheque Number,Šek číslo
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +42,Pressing,Stisknutí
DocType: Payment Tool Detail,Payment Tool Detail,Detail platební nástroj
,Sales Browser,Sales Browser
DocType: Journal Entry,Total Credit,Celkový Credit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +443,Warning: Another {0} # {1} exists against stock entry {2},Upozornění: Dalším {0} # {1} existuje proti akciové vstupu {2}
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +390,Local,Místní
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Úvěrů a půjček (aktiva)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Dlužníci
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +142,Large,Velký
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +18,No employee found!,Žádný zaměstnanec našel!
DocType: C-Form Invoice Detail,Territory,Území
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +162,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +126,Polishing,Leštění
DocType: Production Order Operation,Planned Start Time,Plánované Start Time
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +46,Allocated,Přidělené
apps/erpnext/erpnext/config/accounts.py +63,Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Zadejte Exchange Rate převést jednu měnu na jinou
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +81,Row{0}: Party Type and Party is only applicable against Receivable / Payable account,Row {0}: Type Party Party a je použitelná pouze na pohledávky / závazky účet
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +135,Quotation {0} is cancelled,Nabídka {0} je zrušena
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +26,Total Outstanding Amount,Celková dlužná částka
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} was on leave on {1}. Cannot mark attendance.,Zaměstnanec {0} byl na dovolené na {1}. Nelze označit účast.
DocType: Sales Partner,Targets,Cíle
DocType: Price List,Price List Master,Ceník Master
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Všechny prodejní transakce mohou být označeny proti více ** prodejcům **, takže si můžete nastavit a sledovat cíle."
,S.O. No.,SO Ne.
DocType: Production Order Operation,Make Time Log,Udělejte si čas Přihlásit
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +162,Please create Customer from Lead {0},Prosím vytvořte Zákazník z olova {0}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Computers,Počítače
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +111,Electro-chemical grinding,Electro-chemické broušení
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +14,This is a root customer group and cannot be edited.,"To je kořen skupiny zákazníků, a nelze upravovat."
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +39,Please setup your chart of accounts before you start Accounting Entries,"Prosím, nastavit svůj účtový rozvrh, než začnete účetních zápisů"
DocType: Purchase Invoice,Ignore Pricing Rule,Ignorovat Ceny pravidlo
sites/assets/js/list.min.js +23,Cancelled,Zrušeno
DocType: Employee Education,Graduate,Absolvent
DocType: Leave Block List,Block Days,Blokové dny
DocType: Journal Entry,Excise Entry,Spotřební Entry
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.","Všeobecné obchodní podmínky, které mohou být přidány do prodejů a nákupů.

 Příklady: 

 1. Platnost nabídky.
 1. Platební podmínky (v předstihu, na úvěr, část zálohy atd.)
 1. Co je to další (nebo zaplatit zákazníkem).
 1. Bezpečnost / varování využití.
 1. Záruka, pokud existuje.
 1. Vrátí zásady.
 1. Podmínky přepravy, v případě potřeby.
 1. Způsoby řešení sporů, náhrady škody, odpovědnosti za škodu, atd 
 1. Adresa a kontakt na vaši společnost."
DocType: Attendance,Leave Type,Leave Type
apps/erpnext/erpnext/controllers/stock_controller.py +171,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Náklady / Rozdíl účtu ({0}), musí být ""zisk nebo ztráta"" účet"
DocType: Account,Accounts User,Uživatel Účtů
DocType: Purchase Invoice,"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Zkontrolujte, zda je opakující se faktury, zrušte zaškrtnutí zastavit opakované nebo dát správné datum ukončení"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Účast na zaměstnance {0} je již označen
DocType: Packing Slip,If more than one package of the same type (for print),Pokud je více než jeden balík stejného typu (pro tisk)
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +38,Maximum {0} rows allowed,Maximálně {0} řádků povoleno
DocType: C-Form Invoice Detail,Net Total,Net Total
DocType: Bin,FCFS Rate,FCFS Rate
apps/erpnext/erpnext/accounts/page/pos/pos.js +15,Billing (Sales Invoice),Fakturace (Prodejní Faktura)
DocType: Payment Reconciliation Invoice,Outstanding Amount,Dlužné částky
DocType: Project Task,Working,Pracovní
DocType: Stock Ledger Entry,Stock Queue (FIFO),Sklad fronty (FIFO)
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +13,Please select Time Logs.,Vyberte Time Protokoly.
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +43,{0} does not belong to Company {1},{0} nepatří do Společnosti {1}
,Requested Qty,Požadované množství
DocType: BOM Item,Scrap %,Scrap%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +38,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Poplatky budou rozděleny úměrně na základě položky Množství nebo částkou, dle Vašeho výběru"
DocType: Maintenance Visit,Purposes,Cíle
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +67,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Provoz {0} déle, než všech dostupných pracovních hodin v pracovní stanici {1}, rozložit provoz do několika operací"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +133,Electrochemical machining,Elektrochemické obrábění
,Requested,Požadované
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +62,No Remarks,Žádné poznámky
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +11,Overdue,Zpožděný
DocType: Account,Stock Received But Not Billed,Sklad nepřijali Účtovaný
DocType: Salary Slip,Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Gross Pay + nedoplatek Částka + Inkaso Částka - Total Odpočet
DocType: Monthly Distribution,Distribution Name,Distribuce Name
DocType: Features Setup,Sales and Purchase,Prodej a nákup
DocType: Pricing Rule,Price / Discount,Cena / Sleva
DocType: Purchase Order Item,Material Request No,Materiál Poptávka No
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +201,Quality Inspection required for Item {0},Kontrola kvality potřebný k bodu {0}
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,"Sazba, za kterou zákazník měny je převeden na společnosti základní měny"
DocType: Purchase Invoice,Discount Amount (Company Currency),Částka slevy (Company Měna)
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +105,{0} has been successfully unsubscribed from this list.,{0} byl úspěšně odhlášen z tohoto seznamu.
DocType: Purchase Invoice Item,Net Rate (Company Currency),Čistý Rate (Company měny)
apps/erpnext/erpnext/config/crm.py +71,Manage Territory Tree.,Správa Territory strom.
DocType: Payment Reconciliation Payment,Sales Invoice,Prodejní faktury
DocType: Journal Entry Account,Party Balance,Balance Party
DocType: Sales Invoice Item,Time Log Batch,Time Log Batch
apps/erpnext/erpnext/controllers/taxes_and_totals.py +344,Please select Apply Discount On,"Prosím, vyberte Použít Sleva na"
DocType: Company,Default Receivable Account,Výchozí pohledávek účtu
DocType: Salary Manager,Create Bank Entry for the total salary paid for the above selected criteria,Vytvoření bankovní položka pro celkové vyplacené mzdy za výše zvolených kritérií
DocType: Item,Item will be saved by this name in the data base.,Bod budou uloženy pod tímto jménem v databázi.
DocType: Stock Entry,Material Transfer for Manufacture,Materiál Přenos: Výroba
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +18,Discount Percentage can be applied either against a Price List or for all Price List.,Sleva v procentech lze použít buď proti Ceníku nebo pro všechny Ceníku.
DocType: Purchase Invoice,Half-yearly,Pololetní
apps/erpnext/erpnext/accounts/report/financial_statements.py +16,Fiscal Year {0} not found.,Fiskální rok {0} nebyl nalezen.
DocType: Bank Reconciliation,Get Relevant Entries,Získat příslušné zápisy
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +299,Accounting Entry for Stock,Účetní položka na skladě
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +63,Coining,Ražení
DocType: Sales Invoice,Sales Team1,Sales Team1
apps/erpnext/erpnext/stock/doctype/item/item.py +408,Item {0} does not exist,Bod {0} neexistuje
DocType: Item,"Selecting ""Yes"" will allow you to make a Production Order for this item.","Výběrem ""Yes"" vám umožní, aby se výrobní zakázku pro tuto položku."
DocType: Sales Invoice,Customer Address,Zákazník Address
DocType: Purchase Invoice,Total,Celkem
DocType: Backup Manager,System for managing Backups,Systém pro správu zálohování
DocType: Account,Root Type,Root Type
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +52,Plot,Spiknutí
DocType: Item Group,Show this slideshow at the top of the page,Zobrazit tuto prezentaci v horní části stránky
DocType: BOM,Item UOM,Položka UOM
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Částka daně po slevě Částka (Company měny)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165,Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
DocType: Quality Inspection,Quality Inspection,Kontrola kvality
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +139,Extra Small,Extra Malé
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +19,Spray forming,Spray tváření
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +468,Warning: Material Requested Qty is less than Minimum Order Qty,Upozornění: Materiál Požadované množství je menší než minimální objednávka Množství
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +157,Account {0} is frozen,Účet {0} je zmrazen
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Právní subjekt / dceřiná společnost s oddělenou Graf účtů, které patří do organizace."
apps/erpnext/erpnext/config/setup.py +116,Address master.,Adresa master.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +28,"Food, Beverage & Tobacco","Potraviny, nápoje a tabák"
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +20,PL or BS,PL nebo BS
apps/erpnext/erpnext/controllers/selling_controller.py +127,Commission rate cannot be greater than 100,Rychlost Komise nemůže být větší než 100
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Minimum Inventory Level,Minimální úroveň zásob
DocType: Stock Entry,Subcontract,Subdodávka
DocType: Production Planning Tool,Get Items From Sales Orders,Získat položky z Prodejní Objednávky
DocType: Production Order Operation,Actual End Time,Aktuální End Time
DocType: Production Planning Tool,Download Materials Required,Ke stažení potřebné materiály:
DocType: Item,Manufacturer Part Number,Typové označení
DocType: Production Order Operation,Estimated Time and Cost,Odhadovná doba a náklady
DocType: Bin,Bin,Popelnice
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +49,Nosing,Zaoblená hrana
DocType: SMS Log,No of Sent SMS,Počet odeslaných SMS
DocType: Account,Company,Společnost
DocType: Account,Expense Account,Účtet nákladů
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +48,Software,Software
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +146,Colour,Barevné
DocType: Maintenance Visit,Scheduled,Plánované
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Vyberte měsíční výplatou na nerovnoměrně distribuovat cílů napříč měsíců.
DocType: Purchase Invoice Item,Valuation Rate,Ocenění Rate
DocType: Address,Check to make Shipping Address,Zaškrtněte pro vytvoření doručovací adresy
apps/erpnext/erpnext/stock/get_item_details.py +253,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"""
DocType: Pricing Rule,Applicability,Použitelnost
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +135,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
DocType: Installation Note Item,Against Document No,Proti dokumentu č
apps/erpnext/erpnext/config/selling.py +93,Manage Sales Partners.,Správa prodejních partnerů.
DocType: Quality Inspection,Inspection Type,Kontrola Type
apps/erpnext/erpnext/controllers/recurring_document.py +160,Please select {0},"Prosím, vyberte {0}"
DocType: C-Form,C-Form No,C-Form No
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +90,Researcher,Výzkumník
apps/frappe/frappe/custom/doctype/customize_form/customize_form.js +87,Update,Aktualizovat
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +75,Please save the Newsletter before sending,Uložte Newsletter před odesláním
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +23,Name or Email is mandatory,Jméno nebo e-mail je povinné
apps/erpnext/erpnext/config/stock.py +74,Incoming quality inspection.,Vstupní kontrola jakosti.
DocType: Employee,Exit,Východ
apps/erpnext/erpnext/accounts/doctype/account/account.py +108,Root Type is mandatory,Root Type je povinné
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +292,Serial No {0} created,Pořadové číslo {0} vytvořil
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +124,Vibratory finishing,Vibrační dokončovací
DocType: Item,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pro pohodlí zákazníků, tyto kódy mohou být použity v tiskových formátech, jako na fakturách a dodacích listech"
DocType: Journal Entry Account,Against Purchase Order,Proti vydané objednávce
DocType: Employee,You can enter any date manually,Můžete zadat datum ručně
DocType: Sales Invoice,Advertisement,Reklama
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +160,Probationary Period,Zkušební doba
DocType: Customer Group,Only leaf nodes are allowed in transaction,Pouze koncové uzly jsou povoleny v transakci
DocType: Expense Claim,Expense Approver,Schvalovatel výdajů
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané
sites/assets/js/erpnext.min.js +43,Pay,Platit
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +17,To Datetime,Chcete-li datetime
DocType: SMS Settings,SMS Gateway URL,SMS brána URL
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +136,Grinding,Broušení
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +33,Shrink wrapping,Zmenšit balení
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +52,Supplier > Supplier Type,Dodavatel> Dodavatel Type
apps/erpnext/erpnext/hr/doctype/employee/employee.py +123,Please enter relieving date.,Zadejte zmírnění datum.
apps/erpnext/erpnext/controllers/trends.py +137,Amt,Amt
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +237,Serial No {0} status must be 'Available' to Deliver,"Pořadové číslo {0} status musí být ""k dispozici"" doručovat"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,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ý.
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/page/setup_wizard/fixtures/industry_type.py +37,Newspaper Publishers,Vydavatelé novin
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +31,Select Fiscal Year,Vyberte Fiskální rok
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +87,Smelting,Tavba rudy
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +40,You are the Leave Approver for this record. Please Update the 'Status' and Save,"Jste Leave schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Změna pořadí Level
DocType: Attendance,Attendance Date,Účast Datum
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.
apps/erpnext/erpnext/accounts/doctype/account/account.py +77,Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu
DocType: Address,Preferred Shipping Address,Preferovaná dodací adresa
DocType: Purchase Receipt Item,Accepted Warehouse,Schválené Sklad
DocType: Bank Reconciliation Detail,Posting Date,Datum zveřejnění
DocType: Item,Valuation Method,Ocenění Method
DocType: Sales Invoice,Sales Team,Prodejní tým
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +76,Duplicate entry,Duplicitní záznam
DocType: Serial No,Under Warranty,V rámci záruky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +425,[Error],[Chyba]
DocType: Sales Order,In Words will be visible once you save the Sales Order.,"Ve slovech budou viditelné, jakmile uložíte prodejní objednávky."
,Employee Birthday,Narozeniny zaměstnance
DocType: GL Entry,Debit Amt,Debetní Amt
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +54,Venture Capital,Venture Capital
DocType: UOM,Must be Whole Number,Musí být celé číslo
DocType: Leave Control Panel,New Leaves Allocated (In Days),Nové Listy Přidělené (ve dnech)
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +51,Serial No {0} does not exist,Pořadové číslo {0} neexistuje
DocType: Pricing Rule,Discount Percentage,Sleva v procentech
DocType: Payment Reconciliation Invoice,Invoice Number,Číslo faktury
apps/erpnext/erpnext/shopping_cart/utils.py +44,Orders,Objednávky
DocType: Leave Control Panel,Employee Type,Type zaměstnanců
DocType: Employee Leave Approver,Leave Approver,Nechte schvalovač
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +69,Swaging,Zužování
DocType: Expense Claim,"A user with ""Expense Approver"" role","Uživatel s rolí ""Schvalovatel výdajů"""
,Issued Items Against Production Order,Vydané předmětů proti výrobní zakázky
DocType: Pricing Rule,Purchase Manager,Vedoucí nákupu
DocType: Payment Tool,Payment Tool,Platebního nástroje
DocType: Target Detail,Target Detail,Target Detail
DocType: Sales Order,% of materials billed against this Sales Order,% Materiálů fakturovaných proti tomuto odběrateli
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +50,Period Closing Entry,Období Uzávěrka Entry
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +36,Cost Center with existing transactions can not be converted to group,Nákladové středisko se stávajícími transakcemi nelze převést do skupiny
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +90,Depreciation,Znehodnocení
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Dodavatel (é)
DocType: Email Digest,Payments received during the digest period,Platby přijaté během období digest
DocType: Customer,Credit Limit,Úvěrový limit
DocType: Features Setup,To enable <b>Point of Sale</b> features,Chcete-li povolit <b> Point of Sale </ b> funkce
DocType: Purchase Receipt,LR Date,LR Datum
apps/erpnext/erpnext/accounts/page/pos/pos_page.html +4,Select type of transaction,Vyberte typ transakce
DocType: GL Entry,Voucher No,Voucher No
DocType: Leave Allocation,Leave Allocation,Nechte Allocation
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +398,'Update Stock' for Sales Invoice {0} must be set,"Musí být nastavena ""Aktualizace Skladu"" pro prodejní faktury {0}"
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +402,Material Requests {0} created,Materiál Žádosti {0} vytvořené
apps/erpnext/erpnext/config/selling.py +117,Template of terms or contract.,Šablona podmínek nebo smlouvy.
DocType: Employee,Feedback,Zpětná vazba
apps/erpnext/erpnext/accounts/party.py +192,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Poznámka: Z důvodu / Referenční datum překračuje povolené zákazníků úvěrové dní od {0} den (s)
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +107,Abrasive jet machining,Brusné jet obrábění
DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Příspěvky
DocType: Website Settings,Website Settings,Nastavení www stránky
DocType: Activity Cost,Billing Rate,Fakturace Rate
,Qty to Deliver,Množství k dodání
DocType: Monthly Distribution Percentage,Month,Měsíc
,Stock Analytics,Stock Analytics
DocType: Installation Note Item,Against Document Detail No,Proti Detail dokumentu č
DocType: Quality Inspection,Outgoing,Vycházející
DocType: Material Request,Requested For,Požadovaných pro
DocType: Quotation Item,Against Doctype,Proti DOCTYPE
DocType: Delivery Note,Track this Delivery Note against any Project,Sledovat tento dodacím listu proti jakémukoli projektu
apps/erpnext/erpnext/accounts/doctype/account/account.py +141,Root account can not be deleted,Root účet nemůže být smazán
DocType: GL Entry,Credit Amt,Credit Amt
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +72,Show Stock Entries,Zobrazit Stock Příspěvky
DocType: Production Order,Work-in-Progress Warehouse,Work-in-Progress sklad
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +273,Reference #{0} dated {1},Reference # {0} ze dne {1}
DocType: Pricing Rule,Item Code,Kód položky
DocType: Supplier,Material Manager,Materiál Správce
DocType: Production Planning Tool,Create Production Orders,Vytvoření výrobní zakázky
DocType: Time Log,Costing Rate (per hour),Kalkulace Rate (za hodinu)
DocType: Serial No,Warranty / AMC Details,Záruka / AMC Podrobnosti
DocType: Journal Entry,User Remark,Uživatel Poznámka
apps/erpnext/erpnext/config/accounts.py +117,Point-of-Sale Setting,Nastavení Místa Prodeje
DocType: Lead,Market Segment,Segment trhu
DocType: Communication,Phone,Telefon
DocType: Purchase Invoice,Supplier (Payable) Account,Dodavatel (za poplatek) Account
DocType: Employee Internal Work History,Employee Internal Work History,Interní historie práce zaměstnance
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +192,Closing (Dr),Uzavření (Dr)
DocType: Contact,Passive,Pasivní
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +242,Serial No {0} not in stock,Pořadové číslo {0} není skladem
apps/erpnext/erpnext/config/selling.py +122,Tax template for selling transactions.,Daňové šablona na prodej transakce.
DocType: Sales Invoice,Write Off Outstanding Amount,Odepsat dlužné částky
DocType: Features Setup,"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Zkontrolujte, zda potřebujete automatické opakující faktury. Po odeslání jakékoliv prodejní fakturu, opakující se část bude viditelný."
DocType: Account,Accounts Manager,Accounts Manager
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +36,Time Log {0} must be 'Submitted',"Time Log {0} musí být ""Odesláno"""
DocType: Stock Settings,Default Stock UOM,Výchozí Skladem UOM
DocType: Production Planning Tool,Create Material Requests,Vytvořit Žádosti materiálu
DocType: Employee Education,School/University,Škola / University
DocType: Sales Invoice Item,Available Qty at Warehouse,Množství k dispozici na skladu
,Billed Amount,Fakturovaná částka
DocType: Bank Reconciliation,Bank Reconciliation,Bank Odsouhlasení
DocType: Purchase Invoice,Total Amount To Pay,Celková částka k Zaplatit
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +174,Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena
DocType: Event,Groups,Skupiny
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +85,Group by Account,Seskupit podle účtu
DocType: Sales Order,Fully Delivered,Plně Dodáno
DocType: Lead,Lower Income,S nižšími příjmy
DocType: Period Closing Voucher,"The account head under Liability, in which Profit/Loss will be booked","Účet hlavu pod odpovědnosti, ve kterém se bude Zisk / ztráta rezervovali"
DocType: Payment Tool,Against Vouchers,Proti Poukázky
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +23,Quick Help,Rychlá pomoc
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +184,Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
DocType: Features Setup,Sales Extras,Prodejní Extras
apps/erpnext/erpnext/accounts/utils.py +311,{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} rozpočt na účet {1} proti nákladovému středisku {2} bude vyšší o {3}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +127,Purchase Order number required for Item {0},Číslo vydané objednávky je potřebné k položce {0}
DocType: Leave Allocation,Carry Forwarded Leaves,Carry Předáno listy
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',"""Datum DO"" musí být po ""Datum OD"""
,Stock Projected Qty,Reklamní Plánovaná POČET
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +143,Customer {0} does not belong to project {1},Zákazník {0} nepatří k projektu {1}
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/setup/page/setup_wizard/setup_wizard.js +575,Minute,Minuta
DocType: Purchase Invoice,Purchase Taxes and Charges,Nákup Daně a poplatky
DocType: Backup Manager,Upload Backups to Dropbox,Nahrát zálohy na Dropbox
,Qty to Receive,Množství pro příjem
DocType: Leave Block List,Leave Block List Allowed,Nechte Block List povolena
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +104,Conversion factor cannot be in fractions,Konverzní faktor nemůže být ve zlomcích
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +356,You will use it to Login,Budete ho používat k přihlášení
DocType: Sales Partner,Retailer,Maloobchodník
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +128,All Supplier Types,Všechny typy Dodavatele
apps/erpnext/erpnext/stock/doctype/item/item.py +35,Item Code is mandatory because Item is not automatically numbered,"Kód položky je povinné, protože položka není automaticky číslovány"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +61,Quotation {0} not of type {1},Nabídka {0} není typu {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Plán údržby Item
DocType: Sales Order,%  Delivered,% Dodáno
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +177,Bank Overdraft Account,Kontokorentní úvěr na účtu
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +15,Make Salary Slip,Proveďte výplatní pásce
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +83,Unstop,Uvolnit
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +175,Secured Loans,Zajištěné úvěry
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +49,Ignored:,Ignorovat: 
apps/erpnext/erpnext/shopping_cart/__init__.py +68,{0} cannot be purchased using Shopping Cart,{0} není možné zakoupit pomocí Nákupní košík
apps/erpnext/erpnext/setup/page/setup_wizard/data/sample_home_page.html +3,Awesome Products,Skvělé produkty
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +189,Opening Balance Equity,Počáteční stav Equity
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +80,Cannot approve leave as you are not authorized to approve leaves on Block Dates,Nelze schválit dovolenou si nejste oprávněna schvalovat listy na blok Termíny
DocType: Appraisal,Appraisal,Ocenění
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +12,Lost-foam casting,Lost-pěna lití
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +46,Drawing,Výkres
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +22,Date is repeated,Datum se opakuje
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,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é pořizovací náklady (přes nákupní faktury)
DocType: Workstation Working Hour,Start Time,Start Time
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +183,Select Quantity,Zvolte množství
DocType: Sales Taxes and Charges Template,"Specify a list of Territories, for which, this Taxes Master is valid","Zadejte seznam území, pro které tato Daně Master je platný"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Schválení role nemůže být stejná jako role pravidlo se vztahuje na
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +41,Message Sent,Zpráva byla odeslána
DocType: Production Plan Sales Order,SO Date,SO Datum
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou Ceník měna je převeden na zákazníka základní měny"
DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá částka (Company Měna)
DocType: BOM Operation,Hour Rate,Hour Rate
DocType: Stock Settings,Item Naming By,Položka Pojmenování By
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +650,From Quotation,Z nabídky
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +35,Another Period Closing Entry {0} has been made after {1},Další období Uzávěrka Entry {0} byla podána po {1}
DocType: Production Order,Material Transferred for Manufacturing,Materiál Přenesená pro výrobu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +25,Account {0} does not exists,Účet {0} neexistuje
DocType: Purchase Receipt Item,Purchase Order Item No,Číslo položky vydané objednávky
DocType: System Settings,System Settings,Nastavení systému
DocType: Project,Project Type,Typ projektu
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Buď cílové množství nebo cílová částka je povinná.
apps/erpnext/erpnext/config/projects.py +38,Cost of various activities,Náklady na různých aktivit
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +93,Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0}
DocType: Item,Inspection Required,Kontrola Povinné
DocType: Purchase Invoice Item,PR Detail,PR Detail
DocType: Sales Order,Fully Billed,Plně Fakturovaný
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Pokladní hotovost
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Celková hmotnost balení. Obvykle se čistá hmotnost + obalového materiálu hmotnosti. (Pro tisk)
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Uživatelé s touto rolí se mohou nastavit na zmrazené účty a vytvořit / upravit účetní zápisy proti zmrazených účtů
DocType: Serial No,Is Cancelled,Je Zrušeno
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +291,My Shipments,Moje dodávky
DocType: Journal Entry,Bill Date,Bill Datum
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +43,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","I když existuje více pravidla pro tvorbu cen s nejvyšší prioritou, pak následující interní priority jsou použity:"
DocType: Supplier,Supplier Details,Dodavatele Podrobnosti
DocType: Communication,Recipients,Příjemci
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +145,Screwing,Šroubování
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +95,Knurling,Vroubkování
DocType: Expense Claim,Approval Status,Stav schválení
DocType: Hub Settings,Publish Items to Hub,Publikování položky do Hub
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +38,From value must be less than to value in row {0},Z hodnota musí být menší než hodnota v řadě {0}
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +128,Wire Transfer,Bankovní převod
apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py +25,Please select Bank Account,"Prosím, vyberte bankovní účet"
DocType: Newsletter,Create and Send Newsletters,Vytvoření a odeslání Zpravodaje
sites/assets/js/report.min.js +107,From Date must be before To Date,Datum od musí být dříve než datum do
DocType: Sales Order,Recurring Order,Opakující se objednávky
DocType: Company,Default Income Account,Účet Default příjmů
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +33,Customer Group / Customer,Zákazník Group / Customer
DocType: Item Group,Check this if you want to show in website,"Zaškrtněte, pokud chcete zobrazit v webové stránky"
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +189,Welcome to ERPNext,Vítejte na ERPNext
DocType: Payment Reconciliation Payment,Voucher Detail Number,Voucher Detail Počet
DocType: Lead,From Customer,Od Zákazníka
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +37,Calls,Volá
DocType: Project,Total Costing Amount (via Time Logs),Celková kalkulace Částka (přes Time Záznamy)
DocType: Purchase Order Item Supplied,Stock UOM,Reklamní UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +192,Purchase Order {0} is not submitted,Vydaná objednávka {0} není odeslána
apps/erpnext/erpnext/stock/doctype/item/item.py +161,{0} {1} is entered more than once in Item Variants table,{0} {1} je vloženo více než jednou v  tabulce Varianty  Položky
,Projected,Plánovaná
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} does not belong to Warehouse {1},Pořadové číslo {0} nepatří do skladu {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Note: Reference Date exceeds allowed credit days by {0} days for {1} {2},Poznámka: Odkaz Datum překračuje povolené úvěrové dnů od {0} dní na {1} {2}
apps/erpnext/erpnext/controllers/status_updater.py +96,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,Zpráva Nabídky
DocType: Issue,Opening Date,Datum otevření
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +23,POS Setting {0} already created for user: {1} and company {2},POS nastavení {0} již vytvořili pro uživatele: {1} a společnost {2}
DocType: Journal Entry,Remark,Poznámka
DocType: Purchase Receipt Item,Rate and Amount,Tempo a rozsah
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +94,Boring,Nudný
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +680,From Sales Order,Z přijaté objednávky
DocType: Blog Category,Parent Website Route,nadřazená cesta internetové stránky
DocType: Sales Order,Not Billed,Ne Účtovaný
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +107,Both Warehouse must belong to same Company,Oba Sklady musí patřit do stejné společnosti
sites/assets/js/erpnext.min.js +20,No contacts added yet.,Žádné kontakty přidán dosud.
apps/frappe/frappe/workflow/doctype/workflow/workflow_list.js +7,Not active,Neaktivní
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +43,Against Invoice Posting Date,Proti faktury Datum zveřejnění
DocType: Purchase Receipt Item,Landed Cost Voucher Amount,Přistál Náklady Voucher Částka
DocType: Time Log,Batched for Billing,Zarazeno pro fakturaci
apps/erpnext/erpnext/config/accounts.py +23,Bills raised by Suppliers.,Směnky vznesené dodavately
DocType: POS Setting,Write Off Account,Odepsat účet
DocType: Purchase Invoice,Discount Amount,Částka slevy
DocType: Item,Warranty Period (in days),Záruční doba (ve dnech)
DocType: Email Digest,Expenses booked for the digest period,Náklady rezervované pro období digest
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +500,e.g. VAT,např. DPH
DocType: Journal Entry Account,Journal Entry Account,Zápis do deníku Účet
DocType: Shopping Cart Settings,Quotation Series,Číselná řada nabídek
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +51,"An item exists with same name ({0}), please change the item group name or rename the item","Položka existuje se stejným názvem ({0}), prosím, změnit název skupiny položky nebo přejmenovat položku"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +81,Hot metal gas forming,Tváření Hot metal plyn
DocType: Sales Order Item,Sales Order Date,Prodejní objednávky Datum
DocType: Sales Invoice Item,Delivered Qty,Dodává Množství
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +63,Warehouse {0}: Company is mandatory,Sklad {0}: Společnost je povinná
DocType: Item,Percentage variation in quantity to be allowed while receiving or delivering this item.,"Procentuální změna v množství, aby mohla při přijímání nebo poskytování této položky."
DocType: Shopping Cart Taxes and Charges Master,Shopping Cart Taxes and Charges Master,Nákupní košík daně a poplatky Mistr
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +36,"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.",Přejděte na příslušné skupiny (obvykle zdrojem finančních prostředků&gt; krátkodobých závazků&gt; daní a poplatků a vytvořit nový účet (kliknutím na Přidat dítě) typu &quot;daně&quot; a to nemluvím o daňovou sazbu.
,Payment Period Based On Invoice Date,Platební období na základě data vystavení faktury
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +113,Missing Currency Exchange Rates for {0},Chybí Směnárna Kurzy pro {0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +134,Laser cutting,Laserové řezání
DocType: Event,Monday,Pondělí
DocType: Journal Entry,Stock Entry,Reklamní Entry
DocType: Account,Payable,Splatný
DocType: Salary Slip,Arrear Amount,Nedoplatek Částka
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Noví zákazníci
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Gross Profit %,Hrubý Zisk %
DocType: Appraisal Goal,Weightage (%),Weightage (%)
DocType: Bank Reconciliation Detail,Clearance Date,Výprodej Datum
DocType: Newsletter,Newsletter List,Newsletter Seznam
DocType: Salary Manager,Check if you want to send salary slip in mail to each employee while submitting salary slip,"Zkontrolujte, zda chcete poslat výplatní pásku za poštou na každého zaměstnance při předkládání výplatní pásku"
DocType: Lead,Address Desc,Popis adresy
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +33,Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Rozdíl účet musí být ""Odpovědnost"" typ účtu, protože tento Reklamní Usmíření je Entry Otevření"
apps/erpnext/erpnext/stock/doctype/item/item.js +215,"Variants can not be created manually, add item attributes in the template item","Varianty nelze vytvořit ručně, přidejte atributy položku v položce šablony"
apps/erpnext/erpnext/config/manufacturing.py +34,Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny."
DocType: Page,All,Vše
DocType: Stock Entry Detail,Source Warehouse,Zdroj Warehouse
DocType: Installation Note,Installation Date,Datum instalace
DocType: Employee,Confirmation Date,Potvrzení Datum
DocType: C-Form,Total Invoiced Amount,Celkem Fakturovaná částka
DocType: Communication,Sales User,Uživatel prodeje
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,Min Qty can not be greater than Max Qty,Min množství nemůže být větší než Max Množství
apps/frappe/frappe/core/page/permission_manager/permission_manager.js +421,Set,Nastavit
DocType: Item,Warehouse-wise Reorder Levels,Změna Úrovně dle skladu
DocType: Lead,Lead Owner,Olovo Majitel
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +241,Warehouse is required,Je zapotřebí 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.
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +25,Current BOM and New BOM can not be same,Aktuální BOM a New BOM nemůže být stejné
apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date Of Retirement must be greater than Date of Joining,"Datum odchodu do důchodu, musí být větší než Datum spojování"
DocType: Sales Invoice,Against Income Account,Proti účet příjmů
apps/erpnext/erpnext/controllers/website_list_for_contact.py +52,{0}% Delivered,{0}% vyhlášeno
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +82,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množství {1} nemůže být nižší než minimální Objednané množství {2} (definované v bodu).
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Měsíční Distribution Procento
DocType: Territory,Territory Targets,Území Cíle
DocType: Delivery Note,Transporter Info,Transporter Info
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Dodané položky vydané objednávky
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Dopis hlavy na tiskových šablon.
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,"Tituly na tiskových šablon, např zálohové faktury."
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +140,Valuation type charges can not marked as Inclusive,Poplatky typu ocenění může není označen jako Inclusive
DocType: POS Setting,Update Stock,Aktualizace skladem
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +127,Superfinishing,Superfinišování
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,"Různé UOM položky povede k nesprávné (celkem) Čistá hmotnost hodnoty. Ujistěte se, že čistá hmotnost každé položky je ve stejném nerozpuštěných."
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Rate
DocType: Shopping Cart Settings,"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Přidat / Upravit </a>"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +94,Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list"
apps/erpnext/erpnext/accounts/utils.py +235,Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený
DocType: Purchase Invoice,Terms,Podmínky
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +235,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
,Purchase Analytics,Nákup Analytika
DocType: Sales Invoice Item,Delivery Note Item,Delivery Note Item
DocType: Expense Claim,Task,Úkol
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +56,Shaving,Holení
DocType: Purchase Taxes and Charges,Reference Row #,Referenční Row #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +67,Batch number is mandatory for Item {0},Číslo šarže je povinné pro položku {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +14,This is a root sales person and cannot be edited.,To je kořen prodejní člověk a nelze upravovat.
,Stock Ledger,Reklamní Ledger
DocType: Salary Slip Deduction,Salary Slip Deduction,Plat Slip Odpočet
apps/erpnext/erpnext/stock/doctype/item/item.py +368,"To set reorder level, item must be a Purchase Item","Chcete-li nastavit úroveň Objednací, položka musí být Nákup položky"
apps/frappe/frappe/desk/doctype/note/note_list.js +3,Notes,Poznámky
DocType: Opportunity,From,Od
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +192,Select a group node first.,Vyberte první uzel skupinu.
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Purpose must be one of {0},Cíl musí být jedním z {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +101,Fill the form and save it,Vyplňte formulář a uložte jej
DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,"Stáhněte si zprávu, která obsahuje všechny suroviny s jejich aktuální stav zásob"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +93,Facing,Obložení
DocType: Leave Application,Leave Balance Before Application,Nechte zůstatek před aplikací
DocType: SMS Center,Send SMS,Pošlete SMS
DocType: Company,Default Letter Head,Výchozí hlavičkový
DocType: Time Log,Billable,Zúčtovatelná
DocType: Authorization Rule,This will be used for setting rule in HR module,Tato adresa bude použita pro nastavení pravidlo HR modul
DocType: Account,Rate at which this tax is applied,"Rychlost, při které se používá tato daň"
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +34,Reorder Qty,Změna pořadí Množství
DocType: Company,Stock Adjustment Account,Reklamní Nastavení účtu
DocType: Sales Invoice,Write Off,Odepsat
DocType: Time Log,Operation ID,Provoz ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","System User (login) ID. Pokud je nastaveno, stane se výchozí pro všechny formy HR."
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Z {1}
DocType: Task,depends_on,záleží na
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +81,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"
DocType: Report,Report Type,Typ výpisu
apps/frappe/frappe/core/doctype/user/user.js +136,Loading,Nahrávám
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
apps/erpnext/erpnext/accounts/party.py +196,Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
DocType: Features Setup,If you involve in manufacturing activity. Enables Item 'Is Manufactured',"Pokud se zapojit do výrobní činnosti. Umožňuje Položka ""se vyrábí"""
DocType: Sales Invoice,Rounded Total,Zaoblený Total
DocType: Sales BOM,List items that form the package.,"Seznam položek, které tvoří balíček."
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Podíl alokace by měla být ve výši 100%
DocType: Serial No,Out of AMC,Out of AMC
DocType: Purchase Order Item,Material Request Detail No,Materiál Poptávka Detail No
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +96,Hard turning,Hard soustružení
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +33,Make Maintenance Visit,Proveďte návštěv údržby
apps/erpnext/erpnext/selling/doctype/customer/customer.py +165,Please contact to the user who have Sales Master Manager {0} role,"Prosím, kontaktujte pro uživatele, kteří mají obchodní manažer ve skupině Master {0} roli"
DocType: Company,Default Cash Account,Výchozí Peněžní účet
apps/erpnext/erpnext/config/setup.py +91,Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +68,Please enter 'Expected Delivery Date',"Prosím, zadejte ""Očekávaná Datum dodání"""
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +492,"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Seznam své daňové hlavy (např DPH, spotřební daň, měli by mít jedinečné názvy) a jejich standardní sazby. Tím se vytvoří standardní šablonu, kterou si můžete upravit a přidat další později."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +168,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 +323,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 +69,{0} is not a valid Batch Number for Item {1},{0} není platná Šarže pro Položku {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +109,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
apps/erpnext/erpnext/stock/doctype/item/item.py +165,Please enter atleast one attribute row in Item Variants table,Zadejte prosím aspoň jeden atribut řádek položky Varianty tabulku
DocType: Opportunity,Opportunity Type,Typ Příležitosti
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +42,New Company,Nová společnost
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +50,Cost Center is required for 'Profit and Loss' account {0},"Nákladové středisko je vyžadováno pro účet ""výkaz zisku a ztrát"" {0}"
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +16,Transactions can only be deleted by the creator of the Company,Transakce mohou být vymazány pouze tvůrce Společnosti
apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nesprávný počet hlavní knihy záznamů nalezen. Pravděpodobně jste zvolili nesprávný účet v transakci.
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +31,To create a Bank Account,Chcete-li vytvořit si účet v bance
DocType: Hub Settings,Publish Availability,Publikování Dostupnost
apps/erpnext/erpnext/hr/doctype/employee/employee.py +101,Date of Birth cannot be greater than today.,Datum narození nemůže být větší než dnes.
,Stock Ageing,Reklamní Stárnutí
DocType: Purchase Receipt,Automatically updated from BOM table,Automaticky aktualizována z BOM tabulky
apps/erpnext/erpnext/controllers/accounts_controller.py +170,{0} '{1}' is disabled, {0} '{1}' je zakázána
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Nastavit jako Otevřít
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 +282,"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}"
DocType: Backup Manager,Sync with Dropbox,Synchronizace s Dropbox
DocType: Event,Sunday,Neděle
DocType: Sales Team,Contribution (%),Příspěvek (%)
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +412,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/page/setup_wizard/install_fixtures.py +166,Responsibilities,Odpovědnost
apps/erpnext/erpnext/stock/doctype/item/item_list.js +9,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
DocType: Pricing Rule,Item Group,Položka Group
DocType: Task,Actual Start Date (via Time Logs),Skutečné datum Start (přes Time Záznamy)
DocType: Stock Reconciliation Item,Before reconciliation,Před smíření
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 +334,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/page/setup_wizard/fixtures/operations.py +78,Decambering,Decambering
apps/erpnext/erpnext/setup/doctype/company/company.js +17,Please re-type company name to confirm,Prosím re-typ název společnosti na potvrzení
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +70,Total Outstanding Amt,Celkem Vynikající Amt
DocType: Time Log Batch,Total Hours,Celkem hodin
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +266,Total Debit must be equal to Total Credit. The difference is {0},Celkové inkaso musí rovnat do celkového kreditu. Rozdíl je {0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +10,Automotive,Automobilový
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +40,Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Listy typu {0} již přidělené pro zaměstnance {1} pro fiskální rok {0}
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +15,Item is required,Položka je povinná
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +24,Metal injection molding,Kovové vstřikování
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +697,From Delivery Note,Z Dodacího Listu
DocType: Time Log,From Time,Času od
DocType: Notification Control,Custom Message,Custom Message
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +32,Investment Banking,Investiční bankovnictví
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +259,"Select your Country, Time Zone and Currency","Vyberte svou zemi, časové pásmo a měnu"
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +319,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/selling/doctype/sales_order/sales_order.py +214,{0} {1} status is Unstopped,{0} {1} status je OdZastaveno
DocType: Purchase Invoice,Price List Exchange Rate,Katalogová cena Exchange Rate
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +90,Pickling,Moření
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +17,Sand casting,Lití do písku
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +116,Electroplating,Electroplating
DocType: Purchase Invoice Item,Rate,Rychlost
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +57,Intern,Internovat
DocType: Newsletter,A Lead with this email id should exist,Lead s touto e-mailovou id by měla již existovat
DocType: Stock Entry,From BOM,Od BOM
DocType: Time Log,Billing Rate (per hour),Účtování Rate (za hodinu)
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +34,Basic,Základní
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +86,Stock transactions before {0} are frozen,Fotky transakce před {0} jsou zmrazeny
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +226,Please click on 'Generate Schedule',"Prosím, klikněte na ""Generovat Schedule"""
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +78,To Date should be same as From Date for Half Day leave,Chcete-li data by měla být stejná jako u Datum od půl dne volno
apps/erpnext/erpnext/config/stock.py +110,"e.g. Kg, Unit, Nos, m","např Kg, ks, č, m"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +115,Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni"
apps/erpnext/erpnext/hr/doctype/employee/employee.py +104,Date of Joining must be greater than Date of Birth,Datum přistoupení musí být větší než Datum narození
DocType: Salary Structure,Salary Structure,Plat struktura
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +237,"Multiple Price Rule exists with same criteria, please resolve \
			conflict by assigning priority. Price Rules: {0}","Multiple Cena existuje pravidlo se stejnými kritérii, prosím vyřešit \
 konflikt přiřazením prioritu. Cena Pravidla: {0}"
DocType: Account,Bank,Banka
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +8,Airline,Letecká linka
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +511,Issue Material,Vydání Material
DocType: Material Request Item,For Warehouse,Pro Sklad
DocType: Employee,Offer Date,Nabídka Date
DocType: Hub Settings,Access Token,Přístupový Token
DocType: Sales Invoice Item,Serial No,Výrobní číslo
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +154,Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti"
DocType: Item,Is Fixed Asset Item,Je dlouhodobého majetku Item
DocType: Stock Entry,Including items for sub assemblies,Včetně položek pro podsestav
DocType: Features Setup,"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Máte-li dlouhé formáty tisku, tato funkce může být použita k rozdělení stránku se bude tisknout na více stránek se všemi záhlaví a zápatí na každé straně"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +130,Hobbing,Odvalovací
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +93,All Territories,Všechny území
DocType: Party Type,Party Type Name,Typ Party Name
DocType: Purchase Invoice,Items,Položky
DocType: Fiscal Year,Year Name,Jméno roku
DocType: Salary Manager,Process Payroll,Proces Payroll
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +59,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
DocType: Sales Partner,Sales Partner Name,Sales Partner Name
DocType: Purchase Order Item,Image View,Image View
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +112,Finishing & industrial finishing,Povrchová úprava a průmyslového zpracování
DocType: Issue,Opening Time,Otevírací doba
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Data OD a DO jsou vyžadována
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +45,Securities & Commodity Exchanges,Cenné papíry a komoditních burzách
DocType: Shipping Rule,Calculate Based On,Vypočítat založené na
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +97,Drilling,Vrtání
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +27,Blow molding,Vyfukování
DocType: Purchase Taxes and Charges,Valuation and Total,Oceňování a Total
apps/erpnext/erpnext/stock/doctype/item/item.js +65,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: Sales Order,Customer's Purchase Order Number,Zákazníka Objednávka číslo
DocType: Notification Control,Customize the Notification,Přizpůsobit oznámení
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +86,Hammering,Vyklepání
DocType: Web Page,Slideshow,Promítání obrázků
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
DocType: Sales Invoice,Shipping Rule,Přepravní Pravidlo
DocType: Journal Entry,Print Heading,Tisk záhlaví
DocType: Quotation,Maintenance Manager,Správce údržby
DocType: Workflow State,Search,Hledat
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 +14,'Days Since Last Order' must be greater than or equal to zero,"""Dny od posledního Objednávky"" musí být větší nebo rovny nule"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +141,Brazing,Pájení
DocType: C-Form,Amended From,Platném znění
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +571,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 +146,Child account exists for this account. You can not delete this account.,Dětské konto existuje pro tento účet. Nemůžete smazat tento účet.
apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Buď cílové množství nebo cílová částka je povinná
apps/erpnext/erpnext/stock/get_item_details.py +421,No default BOM exists for Item {0},No default BOM existuje pro bod {0}
DocType: Leave Allocation,Carry Forward,Převádět
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cost Center with existing transactions can not be converted to ledger,Nákladové středisko se stávajícími transakcemi nelze převést na hlavní účetní knihy
DocType: Department,Days for which Holidays are blocked for this department.,"Dnů, po které Prázdniny jsou blokovány pro toto oddělení."
,Produced,Produkoval
DocType: Issue,Raised By (Email),Vznesené (e-mail)
DocType: Email Digest,General,Obecný
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +475,Attach Letterhead,Připojit Hlavičkový
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/stock/doctype/serial_no/serial_no.py +244,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í)
DocType: Blog Post,Blog Post,Příspěvek blogu
apps/erpnext/erpnext/templates/generators/item.html +32,Add to Cart,Přidat do košíku
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Seskupit podle
apps/erpnext/erpnext/config/accounts.py +133,Enable / disable currencies.,Povolit / zakázat měny.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +114,Postal Expenses,Poštovní náklady
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Total (Amt)
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +25,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 +102,{0} must be reduced by {1} or you should increase overflow tolerance,{0} musí být sníženy o {1} nebo byste měli zvýšit toleranci přesahu
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Present,Celkem Present
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +575,Hour,Hodina
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +133,"Serialized Item {0} cannot be updated \
					using Stock Reconciliation","Serialized Položka {0} nelze aktualizovat \
 pomocí Reklamní Odsouhlasení"
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +480,Transfer Material to Supplier,Přeneste materiál Dodavateli
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +30,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 +77,Create Quotation,Vytvořit Citace
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +316,All these items have already been invoiced,Všechny tyto položky již byly fakturovány
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Může být schválena {0}
DocType: Shipping Rule,Shipping Rule Conditions,Přepravní Článek Podmínky
DocType: BOM Replace Tool,The new BOM after replacement,Nový BOM po výměně
DocType: Features Setup,Point of Sale,Místo Prodeje
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +82,Curling,Metaná
DocType: Account,Tax,Daň
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +34,Row {0}: {1} is not a valid {2},Řádek {0}: {1} není platný {2}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +88,Refining,Rafinace
DocType: Production Planning Tool,Production Planning Tool,Plánování výroby Tool
DocType: Quality Inspection,Report Date,Datum Reportu
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +129,Routing,Směrování
DocType: C-Form,Invoices,Faktury
DocType: Job Opening,Job Title,Název pozice
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +84,{0} Recipients,{0} příjemci
DocType: Features Setup,Item Groups in Details,Položka skupiny v detailech
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +32,Expense Account is mandatory,Účtet nákladů je povinný
apps/erpnext/erpnext/accounts/page/pos/pos.js +4,Start Point-of-Sale (POS),Start Point-of-Sale (POS)
DocType: Item,A new variant (Item) will be created for each attribute value combination,Nová varianta (položka) se vytvoří pro každou kombinaci hodnoty atributu
apps/erpnext/erpnext/config/support.py +28,Visit report for maintenance call.,Navštivte zprávu pro volání údržby.
DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,"Procento máte možnost přijímat nebo dodávat více proti objednaného množství. Například: Pokud jste si objednali 100 kusů. a váš příspěvek je 10%, pak máte možnost získat 110 jednotek."
DocType: Pricing Rule,Customer Group,Zákazník Group
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
DocType: Item,Website Description,Popis webu
DocType: Serial No,AMC Expiry Date,AMC Datum vypršení platnosti
,Sales Register,Sales Register
DocType: Quotation,Quotation Lost Reason,Důvod ztráty nabídky
DocType: Address,Plant,Rostlina
apps/frappe/frappe/desk/moduleview.py +64,Setup,Nastavení
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Není nic upravovat.
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +38,Cold rolling,Válcování za studena
DocType: Customer Group,Customer Group Name,Zákazník Group Name
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +358,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: POS Setting,POS Setting,POS Nastavení
DocType: Packing Slip,Get Items,Získat položky
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +185,Please enter Write Off Account,"Prosím, zadejte odepsat účet"
DocType: DocField,Image,Obrázek
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +220,Make Excise Invoice,Proveďte Spotřební faktury
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +628,Make Packing Slip,Proveďte dodacím listem
DocType: Communication,Other,Ostatní
DocType: C-Form,C-Form,C-Form
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +134,Operation ID not set,Provoz ID není nastaveno
DocType: Production Order,Planned Start Date,Plánované datum zahájení
DocType: Serial No,Creation Document Type,Tvorba Typ dokumentu
DocType: Leave Type,Is Encash,Je inkasovat
DocType: Purchase Invoice,Mobile No,Mobile No
DocType: Payment Tool,Make Journal Entry,Proveďte položka deníku
DocType: Leave Allocation,New Leaves Allocated,Nové Listy Přidělené
apps/erpnext/erpnext/controllers/trends.py +257,Project-wise data is not available for Quotation,Data dle projektu nejsou k dispozici pro nabídku
DocType: Project,Expected End Date,Očekávané datum ukončení
DocType: Appraisal Template,Appraisal Template Title,Posouzení Template Název
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +366,Commercial,Obchodní
DocType: Cost Center,Distribution Id,Distribuce Id
apps/erpnext/erpnext/setup/page/setup_wizard/data/sample_home_page.html +14,Awesome Services,Skvělé služby
apps/erpnext/erpnext/config/manufacturing.py +29,All Products or Services.,Všechny výrobky nebo služby.
DocType: Purchase Invoice,Supplier Address,Dodavatel Address
DocType: Contact Us Settings,Address Line 2,Adresní řádek 2
DocType: ToDo,Reference,reference
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +58,Perforating,Perforující
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +35,Out Qty,Out Množství
apps/erpnext/erpnext/config/accounts.py +118,Rules to calculate shipping amount for a sale,Pravidla pro výpočet výše přepravní na prodej
apps/erpnext/erpnext/selling/doctype/customer/customer.py +31,Series is mandatory,Série je povinné
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +27,Financial Services,Finanční služby
DocType: Opportunity,Sales,Prodej
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +166,Warehouse required for stock Item {0},Sklad je vyžadován pro skladovou položku {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +87,Cr,Cr
DocType: Customer,Default Receivable Accounts,Výchozí pohledávka účty
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +101,Sawing,Řezání
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +31,Laminating,Laminování
DocType: Item Reorder,Transfer,Převod
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +567,Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin)
DocType: Authorization Rule,Applicable To (Employee),Vztahující se na (Employee)
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +142,Sintering,Spékání
DocType: Journal Entry,Pay To / Recd From,Platit K / Recd Z
DocType: Naming Series,Setup Series,Řada Setup
DocType: Supplier,Contact HTML,Kontakt HTML
DocType: Landed Cost Voucher,Purchase Receipts,Příjmky
DocType: Payment Reconciliation,Maximum Amount,Maximální částka
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +27,How Pricing Rule is applied?,Jak Ceny pravidlo platí?
DocType: Quality Inspection,Delivery Note No,Dodacího listu
DocType: Company,Retail,Maloobchodní
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +106,Customer {0} does not exist,Zákazník {0} neexistuje
DocType: Attendance,Absent,Nepřítomný
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +164,Crushing,Zdrcující
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kupte Daně a poplatky šablony
DocType: Upload Attendance,Download Template,Stáhnout šablonu
DocType: GL Entry,Remarks,Poznámky
DocType: Purchase Order Item Supplied,Raw Material Item Code,Surovina Kód položky
DocType: Journal Entry,Write Off Based On,Odepsat založené na
DocType: Features Setup,POS View,Zobrazení POS
apps/erpnext/erpnext/config/stock.py +33,Installation record for a Serial No.,Instalace rekord pro sériové číslo
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +8,Continuous casting,Kontinuální lití
sites/assets/js/erpnext.min.js +6,Please specify a,Uveďte prosím
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +490,Make Purchase Invoice,Proveďte nákupní faktury
DocType: Offer Letter,Awaiting Response,Čeká odpověď
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +79,Cold sizing,Cold velikosti
DocType: Salary Slip,Earning & Deduction,Výdělek a dedukce
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +70,Account {0} cannot be a Group,Účet {0} nemůže být skupina
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +257,Region,Kraj
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +208,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 +99,Negative Valuation Rate is not allowed,Negativní ocenění Rate není povoleno
DocType: Holiday List,Weekly Off,Týdenní Off
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Pro např 2012, 2012-13"
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +13,Dropbox,Dropbox
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +32,Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit)
apps/erpnext/erpnext/accounts/utils.py +243,Please set default value {0} in Company {1},Prosím nastavte výchozí hodnotu {0} ve společnosti {1}
DocType: Serial No,Creation Time,Čas vytvoření
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Celkový příjem
,Monthly Attendance Sheet,Měsíční Účast Sheet
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +17,No record found,Nebyl nalezen žádný záznam
apps/erpnext/erpnext/controllers/stock_controller.py +174,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové středisko je povinná k položce {2}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +73,Account {0} is inactive,Účet {0} je neaktivní
DocType: GL Entry,Is Advance,Je Zálohová
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +20,Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinná
apps/erpnext/erpnext/controllers/buying_controller.py +132,Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
DocType: Sales Team,Contact No.,Kontakt Číslo
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,'Profit and Loss' type account {0} not allowed in Opening Entry,"""Výkaz zisku a ztráty"" typ účtu {0} není povoleno pro Vstupní Údaj"
DocType: Workflow State,Time,Čas
DocType: Features Setup,Sales Discounts,Prodejní Slevy
DocType: Hub Settings,Seller Country,Prodejce Country
DocType: Authorization Rule,Authorization Rule,Autorizační pravidlo
DocType: Sales Invoice,Terms and Conditions Details,Podmínky podrobnosti
apps/erpnext/erpnext/templates/generators/item.html +49,Specifications,Specifikace
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Prodej Daně a poplatky šablony
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +9,Apparel & Accessories,Oblečení a doplňky
DocType: Item,"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.","Povinný, pokud skladem, je ""Ano"". Také výchozí sklad, kde je vyhrazeno množství nastavena od odběratele."
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +57,Number of Order,Číslo objednávky
DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, které se zobrazí na první místo v seznamu výrobků."
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Stanovení podmínek pro vypočítat výši poštovného
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +117,Add Child,Přidat dítě
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit Mražené Příspěvky
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +26,Cannot convert Cost Center to ledger as it has child nodes,"Nelze převést nákladového střediska na knihy, protože má podřízené uzly"
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +25,Conversion Factor is required,Je nutná konverzní faktor
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +32,Serial #,Serial #
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +87,Commission on Sales,Provize z prodeje
DocType: Offer Letter Term,Value / Description,Hodnota / Popis
,Customers Not Buying Since Long Time,Zákazníci nekupujete Po dlouhou dobu
DocType: Production Order,Expected Delivery Date,Očekávané datum dodání
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +47,Bulging,Vyboulený
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +10,Evaporative-pattern casting,Lití Evaporative-pattern
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Entertainment Expenses,Výdaje na reprezentaci
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +176,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodejní faktury {0} musí být zrušena před zrušením této prodejní objednávky
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +34,Age,Věk
DocType: Time Log,Billing Amount,Fakturace Částka
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Neplatný množství uvedené na položku {0}. Množství by mělo být větší než 0.
apps/erpnext/erpnext/config/hr.py +18,Applications for leave.,Žádosti o dovolenou.
apps/erpnext/erpnext/accounts/doctype/account/account.py +144,Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Legal Expenses,Výdaje na právní služby
DocType: Sales Order,"The day of the month on which auto order will be generated e.g. 05, 28 etc","Den měsíce, ve kterém auto objednávka bude generován například 05, 28 atd"
DocType: Sales Invoice,Posting Time,Čas zadání
DocType: Sales Order,% Amount Billed,% Fakturované částky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Telephone Expenses,Telefonní Náklady
DocType: Sales Partner,Logo,Logo
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +212,{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} sériová čísla potřebné k položce {0}. Pouze {0} vyplněno.
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Zaškrtněte, pokud chcete, aby uživateli vybrat sérii před uložením. Tam bude žádná výchozí nastavení, pokud jste zkontrolovat."
apps/erpnext/erpnext/stock/get_item_details.py +108,No Item with Serial No {0},No Položka s Serial č {0}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Direct Expenses,Přímé náklady
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +645,Do you really want to UNSTOP this Material Request?,Opravdu chcete uvolnit tento materiál požadavek?
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Nový zákazník Příjmy
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Travel Expenses,Cestovní výdaje
DocType: Maintenance Visit,Breakdown,Rozbor
DocType: Bank Reconciliation Detail,Cheque Date,Šek Datum
apps/erpnext/erpnext/accounts/doctype/account/account.py +43,Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +33,Successfully deleted all transactions related to this company!,Úspěšně vypouští všechny transakce související s tímto společnosti!
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +110,Honing,Honování
DocType: Serial No,"Only Serial Nos with status ""Available"" can be delivered.","Serial pouze Nos se statusem ""K dispozici"" může být dodán."
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +53,Probation,Zkouška
apps/erpnext/erpnext/stock/doctype/item/item.py +94,Default Warehouse is mandatory for stock Item.,Výchozí Sklad je povinný pro živočišnou položky.
DocType: Feed,Full Name,Celé jméno/název
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +147,Clinching,Clinching
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.py +188,Payment of salary for the month {0} and year {1},Platba platu za měsíc {0} a rok {1}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Paid Amount,Celkem uhrazené částky
apps/erpnext/erpnext/accounts/general_ledger.py +91,Debit and Credit not equal for this voucher. Difference is {0}.,Debetní a kreditní nerovná této voucheru. Rozdíl je {0}.
,Transferred Qty,Přenesená Množství
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +132,Planning,Plánování
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +9,Make Time Log Batch,Udělejte si čas Log Batch
DocType: Project,Total Billing Amount (via Time Logs),Celkem Billing Částka (přes Time Záznamy)
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +577,We sell this Item,Nabízíme k prodeji tuto položku
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +66,Supplier Id,Dodavatel Id
DocType: Journal Entry,Cash Entry,Cash Entry
DocType: Sales Partner,Contact Desc,Kontakt Popis
apps/erpnext/erpnext/stock/doctype/item/item.py +190,Item Variants {0} created,Bod Varianty {0} vytvořil
apps/erpnext/erpnext/config/hr.py +135,"Type of leaves like casual, sick etc.","Typ ponechává jako neformální, nevolnosti atd."
DocType: Email Digest,Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy e-mailem.
DocType: Cost Center,Add rows to set annual budgets on Accounts.,Přidat řádky stanovit roční rozpočty na účtech.
DocType: Buying Settings,Default Supplier Type,Výchozí typ Dodavatel
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +159,Quarrying,Těžba
DocType: Production Order,Total Operating Cost,Celkové provozní náklady
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +153,Note: Item {0} entered multiple times,Poznámka: Položka {0} vstoupil vícekrát
apps/erpnext/erpnext/config/crm.py +27,All Contacts.,Všechny kontakty.
DocType: Newsletter,Test Email Id,Testovací Email Id
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +392,Company Abbreviation,Zkratka Company
DocType: Features Setup,If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,"Pokud se budete řídit kontroly jakosti. Umožňuje položky QA požadovány, a QA No v dokladu o koupi"
DocType: GL Entry,Party Type,Typ Party
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +68,Raw material cannot be same as main Item,Surovina nemůže být stejný jako hlavní bod
DocType: Item Attribute Value,Abbreviation,Zkratka
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Není authroized od {0} překročí limity
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +29,Rotational molding,Rotační tváření
apps/erpnext/erpnext/config/hr.py +115,Salary template master.,Plat master šablona.
DocType: Leave Type,Max Days Leave Allowed,Max Days Leave povolena
DocType: Payment Tool,Set Matching Amounts,Nastavit Odpovídající Částky
DocType: Purchase Invoice,Taxes and Charges Added,Daně a poplatky přidané
,Sales Funnel,Prodej Nálevka
apps/erpnext/erpnext/shopping_cart/utils.py +34,Cart,Vozík
,Qty to Transfer,Množství pro přenos
apps/erpnext/erpnext/config/selling.py +18,Quotes to Leads or Customers.,Nabídka pro Lead nebo pro Zákazníka
DocType: Stock Settings,Role Allowed to edit frozen stock,Role povoleno upravovat zmrazené zásoby
,Territory Target Variance Item Group-Wise,Území Cílová Odchylka Item Group-Wise
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +96,All Customer Groups,Všechny skupiny zákazníků
apps/erpnext/erpnext/controllers/accounts_controller.py +366,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možná není vytvořen Měnový Směnný záznam pro {1} až {2}.
apps/erpnext/erpnext/accounts/doctype/account/account.py +37,Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Ceník Rate (Company měny)
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +83,{0} {1} status is 'Stopped',"{0} {1} status je ""Zastaveno"""
DocType: Account,Temporary,Dočasný
DocType: Address,Preferred Billing Address,Preferovaná Fakturační Adresa
DocType: Monthly Distribution Percentage,Percentage Allocation,Procento přidělení
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +81,Secretary,Sekretářka
DocType: Serial No,Distinct unit of an Item,Samostatnou jednotku z položky
apps/erpnext/erpnext/config/setup.py +96,Item master.,Master Item.
DocType: Pricing Rule,Buying,Nákupy
DocType: HR Settings,Employee Records to be created by,"Zaměstnanec Záznamy, které vytvořil"
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +24,This Time Log Batch has been cancelled.,To Batch Time Log byla zrušena.
DocType: Purchase Invoice,Apply Discount On,Použít Sleva na
DocType: Salary Slip Earning,Salary Slip Earning,Plat Slip Zisk
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +161,Creditors,Věřitelé
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Položka Wise Tax Detail
,Item-wise Price List Rate,Item-moudrý Ceník Rate
DocType: Purchase Order Item,Supplier Quotation,Dodavatel Nabídka
DocType: Quotation,In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku."
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +67,Ironing,Žehlení
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +236,{0} {1} is stopped,{0} {1} je zastaven
apps/erpnext/erpnext/stock/doctype/item/item.py +346,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 +127,Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Je nutná zákazník
DocType: Letter Head,Letter Head,Záhlaví
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +32,Shrink fitting,Zmenšit kování
DocType: Email Digest,Income / Expense,Výnosy / náklady
DocType: Employee,Personal Email,Osobní e-mail
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +58,Total Variance,Celkový rozptyl
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Pokud je povoleno, bude systém odesílat účetní položky k zásobám automaticky."
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +14,Brokerage,Makléřská
DocType: Production Order Operation,"in Minutes
Updated via 'Time Log'","v minutách 
 aktualizovat přes ""Time Log"""
DocType: Customer,From Lead,Od Leadu
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 ...
DocType: Hub Settings,Name Token,Jméno Token
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +105,Planing,Hoblování
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +159,Standard Selling,Standardní prodejní
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +153,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
DocType: Serial No,Out of Warranty,Out of záruky
DocType: BOM Replace Tool,Replace,Vyměnit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +281,{0} against Sales Invoice {1},{0} na Prodejní Faktuře {1}
apps/erpnext/erpnext/stock/doctype/item/item.py +47,Please enter default Unit of Measure,"Prosím, zadejte výchozí měrnou jednotku"
DocType: Purchase Invoice Item,Project Name,Název projektu
DocType: Workflow State,Edit,Upravit
DocType: Journal Entry Account,If Income or Expense,Pokud je výnos nebo náklad
DocType: Email Digest,New Support Tickets,Nová podpora Vstupenky
DocType: Features Setup,Item Batch Nos,Položka Batch Nos
DocType: Stock Ledger Entry,Stock Value Difference,Reklamní Value Rozdíl
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Platba Odsouhlasení Platba
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +36,Tax Assets,Daňové Aktiva
DocType: BOM Item,BOM No,BOM No
DocType: Contact Us Settings,Pincode,PSČ
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +147,Journal Entry {0} does not have account {1} or already matched against other voucher,Zápis do deníku {0} nemá účet {1} nebo již uzavřeno proti ostatním poukaz
DocType: Item,Moving Average,Klouzavý průměr
DocType: BOM Replace Tool,The BOM which will be replaced,"BOM, který bude nahrazen"
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +21,New Stock UOM must be different from current stock UOM,New Sklad UOM musí být odlišný od běžného akciové nerozpuštěných
DocType: Account,Debit,Debet
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +32,Leaves must be allocated in multiples of 0.5,"Listy musí být přiděleny v násobcích 0,5"
DocType: Production Order,Operation Cost,Provozní náklady
apps/erpnext/erpnext/config/hr.py +71,Upload attendance from a .csv file,Nahrajte účast ze souboru CSV
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Vynikající Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.
DocType: Warranty Claim,"To assign this issue, use the ""Assign"" button in the sidebar.","Chcete-li přiřadit tento problém vyřešit, použijte tlačítko ""Přiřadit"" v postranním panelu."
DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Zásoby Starší než [dny]
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +40,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Pokud dva nebo více pravidla pro tvorbu cen se nacházejí na základě výše uvedených podmínek, priorita je aplikována. Priorita je číslo od 0 do 20, zatímco výchozí hodnota je nula (prázdný). Vyšší číslo znamená, že bude mít přednost, pokud existuje více pravidla pro tvorbu cen se za stejných podmínek."
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +42,Against Invoice,Na základě faktury
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiskální rok: {0} neexistuje
DocType: Currency Exchange,To Currency,Chcete-li měny
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Nechte následující uživatelé schválit Žádost o dovolenou.
apps/erpnext/erpnext/config/hr.py +155,Types of Expense Claim.,Druhy výdajů nároku.
DocType: Item,Taxes,Daně
DocType: Project,Default Cost Center,Výchozí Center Náklady
DocType: Purchase Invoice,End Date,Datum ukončení
DocType: Employee,Internal Work History,Vnitřní práce History
DocType: DocField,Column Break,Zalomení sloupce
DocType: Event,Thursday,Čtvrtek
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +41,Private Equity,Private Equity
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +92,Turning,Turning
DocType: Maintenance Visit,Customer Feedback,Zpětná vazba od zákazníků
DocType: Account,Expense,Výdaj
DocType: Sales Invoice,Exhibition,Výstava
apps/erpnext/erpnext/stock/utils.py +89,Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem"
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +28,Submit this Production Order for further processing.,Odeslat tento výrobní zakázka pro další zpracování.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +21,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Nechcete-li použít Ceník článek v dané transakce, by měly být všechny platné pravidla pro tvorbu cen zakázáno."
DocType: Company,Domain,Doména
,Sales Order Trends,Prodejní objednávky Trendy
DocType: Employee,Held On,Které se konalo dne
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +24,Production Item,Výrobní položka
,Employee Information,Informace o zaměstnanci
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +502,Rate (%),Rate (%)
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +405,Financial Year End Date,Finanční rok Datum ukončení
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +32,"Can not filter based on Voucher No, if grouped by Voucher","Nelze filtrovat na základě poukazu ne, pokud seskupeny podle poukazu"
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +502,Make Supplier Quotation,Vytvořit nabídku dodavatele
DocType: Quality Inspection,Incoming,Přicházející
DocType: Item,Name and Description,Jméno a popis
apps/erpnext/erpnext/stock/doctype/item/item.py +134,"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.","Výchozí Měrná jednotka nelze změnit, přímo, protože jste již nějaké transakce (y) s jiným nerozpuštěných. Chcete-li změnit výchozí UOM, použijte ""UOM Nahradit Utility"" nástroj pod Stock modulu."
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/setup/page/setup_wizard/install_fixtures.py +44,Casual Leave,Casual Leave
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +92,Credit To account must be a liability account,Připsat na účet musí být účet závazek
DocType: Batch,Batch ID,Šarže ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +303,Note: {0},Poznámka: {0}
,Delivery Note Trends,Dodací list Trendy
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +72,{0} must be a Purchased or Sub-Contracted Item in row {1},"{0} musí být Zakoupená, nebo Subdodavatelská položka v řádku {1}"
apps/erpnext/erpnext/accounts/general_ledger.py +100,Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím Skladových Transakcí
DocType: GL Entry,Party,Strana
DocType: Sales Order,Delivery Date,Dodávka Datum
DocType: DocField,Currency,Měna
DocType: Opportunity,Opportunity Date,Příležitost Datum
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +10,To Bill,Billa
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +56,Piecework,Úkolová práce
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +64,Avg. Buying Rate,Avg. Nákup Rate
DocType: Task,Actual Time (in Hours),Skutečná doba (v hodinách)
DocType: Employee,History In Company,Historie ve Společnosti
DocType: Address,Shipping,Lodní
DocType: Stock Ledger Entry,Stock Ledger Entry,Reklamní Ledger Entry
DocType: Department,Leave Block List,Nechte Block List
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +203,Item {0} is not setup for Serial Nos. Column must be blank,Položka {0} není nastavení pro Serial č. Sloupec musí být prázdný
DocType: Accounts Settings,Accounts Settings,Nastavení účtu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +53,Plant and Machinery,Továrna a strojní zařízení
DocType: Item,You can enter the minimum quantity of this item to be ordered.,Můžete zadat minimální množství této položky do objednávky.
DocType: Sales Partner,Partner's Website,Partnera Website
DocType: Opportunity,To Discuss,K projednání
DocType: SMS Settings,SMS Settings,Nastavení SMS
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +60,Temporary Accounts,Dočasné Účty
DocType: Payment Tool,Column Break 1,Zalomení sloupce 1
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +150,Black,Černá
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Item
DocType: Account,Auditor,Auditor
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,Vytvořte nabídku Letter
DocType: DocField,Fold,Fold
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
sites/assets/js/desk.min.js +558,Please specify,Prosím specifikujte
DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku)
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py +65,Customer Id,Zákazník Id
DocType: Page,Page Name,Název stránky
DocType: Purchase Invoice,Exchange Rate,Exchange Rate
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +422,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}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +123,Spindle finishing,Úprava vřetena
DocType: Material Request,% of materials ordered against this Material Request,% Materiálů objednáno proti tomuto požadavku Materiál
DocType: BOM,Last Purchase Rate,Last Cena při platbě
DocType: Account,Asset,Majetek
DocType: Project Task,Task ID,Task ID
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +393,"e.g. ""MC""","např ""MC """
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +75,Stock cannot exist for Item {0} since has variants,"Sklad nemůže existovat k bodu {0}, protože má varianty"
,Sales Person-wise Transaction Summary,Prodej Person-moudrý Shrnutí transakce
DocType: System Settings,Time Zone,Časové pásmo
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +104,Warehouse {0} does not exist,Sklad {0} neexistuje
apps/erpnext/erpnext/hub_node/page/hub/register_in_hub.html +2,Register For ERPNext Hub,Registrace pro ERPNext Hub
DocType: Monthly Distribution,Monthly Distribution Percentages,Měsíční Distribuční Procenta
apps/erpnext/erpnext/stock/doctype/batch/batch.py +16,The selected item cannot have Batch,Vybraná položka nemůže mít dávku
DocType: Delivery Note,% of materials delivered against this Delivery Note,% Materiálů doručeno proti tomuto dodacímu listu
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +150,Stapling,Sešívání
DocType: Customer,Customer Details,Podrobnosti zákazníků
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +104,Shaping,Tvarování
DocType: Employee,Reports to,Zprávy
DocType: SMS Settings,Enter url parameter for receiver nos,Zadejte url parametr pro přijímače nos
DocType: Sales Invoice,Paid Amount,Uhrazené částky
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +25,Closing Account {0} must be of type 'Liability',"Závěrečný účet {0} musí být typu ""odpovědnosti"""
,Available Stock for Packing Items,K dispozici skladem pro balení položek
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275,Reserved Warehouse is missing in Sales Order,Reserved Warehouse chybí odběratele
DocType: Item Variant,Item Variant,Položka Variant
apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +15,Setting this Address Template as default as there is no other default,"Nastavení Tato adresa šablonu jako výchozí, protože není jiná výchozí"
apps/erpnext/erpnext/accounts/doctype/account/account.py +71,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +71,Quality Management,Řízení kvality
DocType: Production Planning Tool,Filter based on customer,Filtr dle zákazníka
DocType: Payment Tool Detail,Against Voucher No,Proti poukaz č
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +46,Please enter quantity for Item {0},"Zadejte prosím množství produktů, bod {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +35,Warning: Sales Order {0} already exists against same Purchase Order number,Upozornění: prodejní objednávky {0} již existuje proti stejnému číslo objednávky
DocType: Employee External Work History,Employee External Work History,Zaměstnanec vnější práce History
DocType: Notification Control,Purchase,Nákup
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +178,Status of {0} {1} is now {2},Stav {0} {1} je nyní {2}
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +29,Balance Qty,Zůstatek Množství
DocType: Item Group,Parent Item Group,Parent Item Group
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +18,{0} for {1},{0} na {1}
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +92,Cost Centers,Nákladové středisko
apps/erpnext/erpnext/config/stock.py +115,Warehouses.,Sklady.
DocType: Purchase Order,Rate at which supplier's currency is converted to company's base currency,"Sazba, za kterou dodavatel měny je převeden na společnosti základní měny"
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: časování v rozporu s řadou {1}
DocType: 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
DocType: Item Group,Default Expense Account,Výchozí výdajového účtu
DocType: Employee,Notice (days),Oznámení (dny)
DocType: Page,Yes,Ano
DocType: Cost Center,Material User,Materiál Uživatel
DocType: Employee,Encashment Date,Inkaso Datum
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +73,Electroforming,Electroforming
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +147,"Against Voucher Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Proti poukazu Type musí být jedním z objednávky, faktury nebo Journal Entry"
DocType: Account,Stock Adjustment,Reklamní Nastavení
DocType: Production Order,Planned Operating Cost,Plánované provozní náklady
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +118,New {0} Name,Nový {0} Název
apps/erpnext/erpnext/controllers/recurring_document.py +126,Please find attached {0} #{1},V příloze naleznete {0} # {1}
DocType: Global Defaults,jsonrates.com API Key,jsonrates.com API Key
DocType: Job Applicant,Applicant Name,Žadatel Název
DocType: Authorization Rule,Customer / Item Name,Zákazník / Název zboží
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Serial No is mandatory for Item {0},Pořadové číslo je povinná k bodu {0}
sites/assets/js/desk.min.js +536,Created By,Vytvořeno (kým)
DocType: Serial No,Under AMC,Podle AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +47,Item valuation rate is recalculated considering landed cost voucher amount,Bod míra ocenění je přepočítána zvažuje přistál nákladů částku poukazu
apps/erpnext/erpnext/config/selling.py +65,Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.
DocType: BOM Replace Tool,Current BOM,Aktuální BOM
sites/assets/js/erpnext.min.js +5,Add Serial No,Přidat Sériové číslo
DocType: Production Order,Warehouses,Sklady
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Print and Stationary,Print a Stacionární
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +119,Group Node,Group Node
DocType: Payment Reconciliation,Minimum Amount,Minimální částka
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +68,Update Finished Goods,Dokončení aktualizace zboží
DocType: Item,"Automatically set. If this item has variants, then it cannot be selected in sales orders etc.","Automatické nastavení. Pokud je tato položka má varianty, pak to nemůže být zvolen do prodejních objednávek atd"
DocType: Workstation,per hour,za hodinu
apps/frappe/frappe/core/doctype/doctype/doctype.py +97,Series {0} already used in {1},Série {0} jsou již použity v {1}
DocType: Warehouse,Account for the warehouse (Perpetual Inventory) will be created under this Account.,"Účet pro skladu (průběžné inventarizace), bude vytvořena v rámci tohoto účtu."
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +95,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse nelze vypustit, neboť existuje zásob, kniha pro tento sklad."
DocType: Company,Distribution,Distribuce
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +86,Project Manager,Project Manager
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +67,Dispatch,Odeslání
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +70,Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
DocType: Account,Receivable,Pohledávky
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Role, která se nechá podat transakcí, které přesahují úvěrové limity."
DocType: Sales Invoice,Supplier Reference,Dodavatel Označení
DocType: Production Planning Tool,"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Je-li zaškrtnuto, bude BOM pro sub-montážní položky považují pro získání surovin. V opačném případě budou všechny sub-montážní položky být zacházeno jako surovinu."
DocType: Material Request,Material Issue,Material Issue
DocType: Hub Settings,Seller Description,Prodejce Popis
DocType: Item,Is Stock Item,Je skladem
DocType: Shopping Cart Price List,Shopping Cart Price List,Nákupní košík Ceník
DocType: Employee Education,Qualification,Kvalifikace
DocType: Item Price,Item Price,Položka Cena
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +47,Soap & Detergent,Soap & Detergent
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +35,Motion Picture & Video,Motion Picture & Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Objednáno
DocType: Company,Default Settings,Výchozí nastavení
DocType: Warehouse,Warehouse Name,Název Skladu
DocType: Naming Series,Select Transaction,Vybrat Transaction
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel
DocType: Journal Entry,Write Off Entry,Odepsat Vstup
DocType: BOM,Rate Of Materials Based On,Hodnotit materiálů na bázi
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Podpora Analtyics
DocType: Journal Entry,eg. Cheque Number,např. číslo šeku
apps/erpnext/erpnext/accounts/doctype/accounts_settings/accounts_settings.py +25,Company is missing in warehouses {0},Společnost chybí ve skladech {0}
DocType: Stock UOM Replace Utility,Stock UOM Replace Utility,Sklad UOM Nahradit Utility
DocType: POS Setting,Terms and Conditions,Podmínky
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,To Date should be within the Fiscal Year. Assuming To Date = {0},"Chcete-li data by měla být v rámci fiskálního roku. Za předpokladu, že To Date = {0}"
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Zde si můžete udržet výšku, váhu, alergie, zdravotní problémy atd"
DocType: Leave Block List,Applies to Company,Platí pro firmy
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +156,Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože předložena Reklamní Entry {0} existuje"
DocType: Purchase Invoice,In Words,Slovy
apps/erpnext/erpnext/hr/doctype/employee/employee.py +204,Today is {0}'s birthday!,Dnes je {0} 's narozeniny!
DocType: Production Planning Tool,Material Request For Warehouse,Materiál Request For Warehouse
DocType: Sales Order Item,For Production,Pro Výrobu
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +107,Please enter sales order in the above table,"Prosím, zadejte prodejní objednávky v tabulce výše"
DocType: Project Task,View Task,Zobrazit Task
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +404,Your financial year begins on,Váš finanční rok začíná
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 +471,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),Nastavení příchozí server pro podporu e-mailovou id. (Např support@example.com)
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +35,Shortage Qty,Nedostatek Množství
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +79,Row{0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Type Party Party a je nutné pro pohledávky / závazky na účtu {1}
DocType: Salary Slip,Salary Slip,Plat Slip
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +115,Burnishing,Leštění
DocType: Features Setup,To enable <b>Point of Sale</b> view,Chcete-li povolit <b> Point of Sale </ b> Zobrazit
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +54,'To Date' is required,"""Datum DO"" je povinné"
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generování balení pásky pro obaly mají být dodány. Používá se k oznámit číslo balíku, obsah balení a jeho hmotnost."
DocType: Sales Invoice Item,Sales Order Item,Prodejní objednávky Item
DocType: Salary Slip,Payment Days,Platební dny
DocType: BOM,Manage cost of operations,Správa nákladů na provoz
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +86,Make Credit Note,Proveďte dobropis
DocType: Features Setup,Item Advanced,Položka Advanced
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +39,Hot rolling,Válcování
DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Když některý z kontrolovaných operací je ""Odesláno"", email pop-up automaticky otevřeny poslat e-mail na přidružené ""Kontakt"" v této transakci, s transakcí jako přílohu. Uživatel může, ale nemusí odeslat e-mail."
apps/erpnext/erpnext/config/setup.py +101,Customer master.,Master zákazníků.
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globální nastavení
DocType: Employee Education,Employee Education,Vzdělávání zaměstnanců
DocType: Salary Slip,Net Pay,Net Pay
DocType: Account,Account,Účet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} has already been received,Pořadové číslo {0} již obdržel
,Requested Items To Be Transferred,Požadované položky mají být převedeny
DocType: Purchase Invoice,Recurring Id,Opakující se Id
DocType: Customer,Sales Team Details,Podrobnosti prodejní tým
DocType: Expense Claim,Total Claimed Amount,Celkem žalované částky
apps/erpnext/erpnext/config/crm.py +22,Potential opportunities for selling.,Potenciální příležitosti pro prodej.
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +46,Sick Leave,Zdravotní dovolená
DocType: Email Digest,Email Digest,Email Digest
DocType: Delivery Note,Billing Address Name,Jméno Fakturační adresy
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +21,Department Stores,Obchodní domy
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +39,System Balance,System Balance
DocType: Workflow,Is Active,Je Aktivní
apps/erpnext/erpnext/controllers/stock_controller.py +70,No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady
apps/erpnext/erpnext/projects/doctype/project/project.js +22,Save the document first.,Uložte dokument jako první.
DocType: Account,Chargeable,Vyměřovací
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +120,Linishing,Linishing
DocType: Company,Change Abbreviation,Změna Zkratky
DocType: Workflow State,Primary,Primární
DocType: Expense Claim Detail,Expense Date,Datum výdaje
DocType: Item,Max Discount (%),Max sleva (%)
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +60,Last Order Amount,Poslední částka objednávky
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +160,Blasting,Odstřel
DocType: Company,Warn,Varovat
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +82,Item valuation updated,Ocenění Item aktualizováno
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Jakékoli jiné poznámky, pozoruhodné úsilí, které by měly jít v záznamech."
DocType: BOM,Manufacturing User,Výroba Uživatel
DocType: Purchase Order,Raw Materials Supplied,Dodává suroviny
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239,Total valuation ({0}) for manufactured or repacked item(s) can not be less than total valuation of raw materials ({1}),Ocenění Total ({0}) pro vyrobené nebo zabalil položku (y) nesmí být menší než celková ocenění surovin ({1})
DocType: Email Digest,New Projects,Nové projekty
DocType: Communication,Series,Série
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +28,Expected Delivery Date cannot be before Purchase Order Date,"Očekávané datum dodání, nemůže být před zakoupením pořadí Datum"
DocType: Appraisal,Appraisal Template,Posouzení Template
DocType: Communication,Email,Email
DocType: Item Group,Item Classification,Položka Klasifikace
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +84,Business Development Manager,Business Development Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Maintenance Visit Účel
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +15,Period,Období
,General Ledger,Hlavní Účetní Kniha
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Zobrazit Vodítka
DocType: Item Attribute Value,Attribute Value,Hodnota atributu
apps/erpnext/erpnext/crm/doctype/lead/lead.py +65,"Email id must be unique, already exists for {0}","E-mail id musí být jedinečný, již existuje {0}"
,Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +216,Please select {0} first,"Prosím, nejprve vyberte {0} "
DocType: Features Setup,To get Item Group in details table,Chcete-li získat položku Group v tabulce Rozpis
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +66,Redrawing,Překreslení
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +119,Etching,Lept
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +55,Commission,Provize
apps/erpnext/erpnext/templates/pages/ticket.py +31,You are not allowed to reply to this ticket.,Nejste oprávnění odpovědět na tento lístek.
DocType: Address Template,"<h4>Default Template</h4>
<p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p>
<pre><code>{{ address_line1 }}&lt;br&gt;
{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}
{{ city }}&lt;br&gt;
{% if state %}{{ state }}&lt;br&gt;{% endif -%}
{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}
{{ country }}&lt;br&gt;
{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}
{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}
{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}
</code></pre>","<H4> Default Template </ h4> 
 <p> <a Používá href=""http://jinja.pocoo.org/docs/templates/""> Jinja šablon </a> a všechna pole Adresa ( včetně Custom Fields-li nějaké) budou k dispozici </ p> 
 <pre> <code> {{address_line1}} & lt; br & gt; 
 {%, pokud address_line2%} {{address_line2}} & lt; br & gt; { % endif -%} {
 {}} city & lt; br & gt; 
 {%, pokud stav%} {{}} state & lt; br & gt; {% endif -%} {
% v případě, PSC%} PIN: {{PSC}} & lt; br & gt; {% endif -%} 
 {{country}} & lt; br & gt; 
 {%, pokud telefon%} Telefon: {{tel}} & lt; br & gt; { % endif -%} 
 {% v případě, fax%} Fax: {{fax}} & lt; br & gt; {% endif -%} 
 {%, pokud email_id%} E-mail: {{email_id}} & lt; br & gt ; {% endif -%} 
 </ code> </ pre>"
DocType: Salary Slip Deduction,Default Amount,Výchozí částka
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +84,Warehouse not found in the system,Sklad nebyl nalezen v systému
DocType: Quality Inspection Reading,Quality Inspection Reading,Kvalita Kontrola Reading
DocType: Party Account,col_break1,col_break1
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,`Zmrazit Zásoby Starší Vic jak` by měla být menší než %d dnů.
,Project wise Stock Tracking,Sledování zboží dle projektu
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +176,Maintenance Schedule {0} exists against {0},Plán údržby {0} existuje na {0}
DocType: Stock Entry Detail,Actual Qty (at source/target),Skutečné množství (u zdroje/cíle)
DocType: Item Customer Detail,Ref Code,Ref Code
apps/erpnext/erpnext/config/hr.py +13,Employee records.,Zaměstnanecké záznamy.
DocType: HR Settings,Payroll Settings,Nastavení Mzdové
apps/erpnext/erpnext/config/accounts.py +58,Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
DocType: Email Digest,New Purchase Orders,Nové vydané objednávky
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Root cannot have a parent cost center,Root nemůže mít rodič nákladové středisko
DocType: Sales Invoice,C-Form Applicable,C-Form Použitelné
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM konverze Detail
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +476,Keep it web friendly 900px (w) by 100px (h),Keep It webové přátelské 900px (w) o 100px (h)
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +44,Charges are updated in Purchase Receipt against each item,Poplatky jsou aktualizovány v dokladu o koupi na každou položku
DocType: Payment Tool,Get Outstanding Vouchers,Získejte Vynikající poukazy
DocType: Warranty Claim,Resolved By,Vyřešena
DocType: Appraisal,Start Date,Datum zahájení
sites/assets/js/desk.min.js +512,Value,Hodnota
apps/erpnext/erpnext/config/hr.py +130,Allocate leaves for a period.,Přidělit listy dobu.
apps/erpnext/erpnext/accounts/doctype/account/account.py +39,Account {0}: You can not assign itself as parent account,Účet {0}: nelze přiřadit sebe jako nadřazený účet
DocType: Purchase Invoice Item,Price List Rate,Ceník Rate
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +166,Delivered Serial No {0} cannot be deleted,Dodává Pořadové číslo {0} nemůže být smazán
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Zobrazit ""Skladem"" nebo ""Není skladem"" na základě skladem k dispozici v tomto skladu."
apps/erpnext/erpnext/config/manufacturing.py +13,Bill of Materials (BOM),Bill of Materials (BOM)
DocType: Time Log,Hours,Hodiny
DocType: Project,Expected Start Date,Očekávané datum zahájení
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +37,Rolling,Rolling
DocType: ToDo,Priority,Priorita
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +168,"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Nelze smazat sériové číslo {0} na skladě. Nejprve odstraňte ze skladu, a pak smažte."
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +41,Remove item if charges is not applicable to that item,Odebrat pokud poplatků není pro tuto položku
DocType: Backup Manager,Dropbox Access Allowed,Dropbox Přístup povolen
DocType: Backup Manager,Weekly,Týdenní
DocType: SMS Settings,Eg. smsgateway.com/api/send_sms.cgi,Např. smsgateway.com/api/send-sms.cgi
DocType: Maintenance Visit,Fully Completed,Plně Dokončeno
DocType: Item,"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Produkty budou rozděleny dle hmotnosti věku ve výchozím vyhledávání. Více váha věku, bude vyšší výrobek objeví v seznamu."
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Hotovo
DocType: Employee,Educational Qualification,Vzdělávací Kvalifikace
DocType: Workstation,Operating Costs,Provozní náklady
DocType: Employee Leave Approver,Employee Leave Approver,Zaměstnanec Leave schvalovač
apps/erpnext/erpnext/templates/includes/footer_extension.html +9,Stay Updated,Zůstaňte Aktualizováno
apps/erpnext/erpnext/stock/doctype/item/item.py +376,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 +66,"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +132,Electron beam machining,Paprsek obrábění Electron
DocType: Purchase Taxes and Charges Template,Purchase Master Manager,Nákup Hlavní manažer
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +468,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 +160,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 +141,Main Reports,Hlavní zprávy
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +73,Stock Ledger entries balances updated,Sklad Ledger položky bilancí aktualizováno
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 +201,Add / Edit Prices,Přidat / Upravit ceny
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +54,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 +238,My Orders,Moje objednávky
DocType: Price List,Price List Name,Ceník Jméno
DocType: Time Log,For Manufacturing,Pro výrobu
DocType: BOM,Manufacturing,Výroba
,Ordered Items To Be Delivered,"Objednané zboží, které mají být dodány"
DocType: Account,Income,Příjem
,Setup Wizard,Průvodce nastavením
DocType: Industry Type,Industry Type,Typ Průmyslu
apps/erpnext/erpnext/templates/includes/cart.js +264,Something went wrong!,Něco se pokazilo!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +68,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 +235,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)
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +9,Die casting,Die lití
DocType: Email Alert,Reference Date,Referenční data
apps/erpnext/erpnext/config/hr.py +105,Organization unit (department) master.,Organizace jednotka (departement) master.
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +25,Please enter valid mobile nos,Zadejte platné mobilní nos
DocType: Email Digest,User Specific,Uživatel Specifické
DocType: Budget Detail,Budget Detail,Detail Rozpočtu
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +73,Please enter message before sending,"Prosím, zadejte zprávu před odesláním"
DocType: Communication,Status,Stav
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +36,Stock UOM updated for Item {0},Sklad UOM aktualizovaný k bodu {0}
DocType: Company History,Year,Rok
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +69,Please Update SMS Settings,Aktualizujte prosím nastavení SMS
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +34,Time Log {0} already billed,Time Log {0} již účtoval
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +176,Unsecured Loans,Nezajištěných úvěrů
DocType: Cost Center,Cost Center Name,Jméno nákladového střediska
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Item {0} with Serial No {1} is already installed,Položka {0} s Serial č {1} je již nainstalován
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +10,You can start by selecting backup frequency and granting access for sync,Můžete začít výběrem frekvence zálohování a poskytnutím přístupu pro synchronizaci
DocType: Maintenance Schedule Detail,Scheduled Date,Plánované datum
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +69,Total Paid Amt,Celkem uhrazeno Amt
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Zprávy větší než 160 znaků bude rozdělena do více zpráv
DocType: Purchase Receipt Item,Received and Accepted,Přijaté a Přijato
DocType: Item Attribute,"Lower the number, higher the priority in the Item Code suffix that will be created for this Item Attribute for the Item Variant","Nižší číslo, vyšší prioritu v položce kódu příponu, který bude vytvořen pro tuto položku atribut výtisku Variant"
,Serial No Service Contract Expiry,Pořadové číslo Servisní smlouva vypršení platnosti
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +79,Employee can not be changed,Zaměstnanec nemůže být změněn
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +257,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 +100,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.,"Jméno osoby nebo organizace, která tato adresa patří."
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +536,Your Suppliers,Vaši Dodavatelé
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +62,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 +58,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
DocType: Features Setup,Exports,Vývoz
DocType: Lead,Converted,Převedené
DocType: Item,Has Serial No,Má Sériové číslo
DocType: Employee,Date of Issue,Datum vydání
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +16,{0}: From {0} for {1},{0}: Od {0} do {1}
DocType: Issue,Content Type,Typ obsahu
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +16,Computer,Počítač
DocType: Item,List this Item in multiple groups on the website.,Seznam tuto položku ve více skupinách na internetových stránkách.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +62,Item: {0} does not exist in the system,Položka: {0} neexistuje v systému
apps/erpnext/erpnext/accounts/doctype/account/account.py +63,You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení
DocType: Payment Reconciliation,Get Unreconciled Entries,Získat smířit záznamů
DocType: Purchase Receipt,Date on which lorry started from supplier warehouse,"Ode dne, kdy začal nákladního vozidla od dodavatele skladu"
DocType: Cost Center,Budgets,Rozpočty
apps/frappe/frappe/core/page/modules_setup/modules_setup.py +11,Updated,Aktualizováno
DocType: Employee,Emergency Contact Details,Nouzové kontaktní údaje
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +394,What does it do?,Co to dělá?
DocType: Delivery Note,To Warehouse,Do skladu
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +56,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 +298,'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemůže být ""ano"" pro neskladové zboží"
apps/erpnext/erpnext/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
DocType: Price List,"Specify a list of Territories, for which, this Price List is valid","Zadejte seznam území, pro které tato Ceník je platný"
apps/erpnext/erpnext/config/stock.py +79,Update additional costs to calculate landed cost of items,Aktualizace dodatečné náklady pro výpočet vyložené náklady položek
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +106,Electrical,Elektrický
DocType: Stock Entry,Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +94,Difference Account mandatory for purpose '{0}',Rozdíl Účet povinné pro účely &#39;{0}&#39;
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},User ID není nastavena pro zaměstnance {0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +71,Peening,Peening
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +30,From Warranty Claim,Od reklamačnímu
DocType: Stock Entry,Default Source Warehouse,Výchozí zdroj Warehouse
DocType: Item,Customer Code,Code zákazníků
apps/erpnext/erpnext/hr/doctype/employee/employee.py +203,Birthday Reminder for {0},Narozeninová připomínka pro {0}
DocType: Item,Default Purchase Account in which cost of the item will be debited.,"Default Nákup účet, na němž se bude zatížen náklady na položky."
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +162,Lapping,Zabrušovací
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.js +8,Days Since Last Order,Počet dnů od poslední objednávky
DocType: Buying Settings,Naming Series,Číselné řady
DocType: Leave Block List,Leave Block List Name,Nechte Jméno Block List
DocType: User,Enabled,Zapnuto
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Stock Aktiva
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +22,Do you really want to Submit all Salary Slip for month {0} and year {1},"Opravdu chcete, aby předložila všechny výplatní pásce za měsíc {0} a rok {1}"
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +8,Import Subscribers,Importovat Odběratelé
DocType: Target Detail,Target Qty,Target Množství
DocType: Attendance,Present,Současnost
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +35,Delivery Note {0} must not be submitted,Delivery Note {0} nesmí být předloženy
DocType: Notification Control,Sales Invoice Message,Prodejní faktury Message
DocType: Email Digest,Income Booked,Rezervováno příjmů
DocType: Authorization Rule,Based On,Založeno na
,Ordered Qty,Objednáno Množství
DocType: Stock Settings,Stock Frozen Upto,Reklamní Frozen aľ
apps/erpnext/erpnext/config/projects.py +13,Project activity / task.,Projektová činnost / úkol.
apps/erpnext/erpnext/config/hr.py +65,Generate Salary Slips,Generování výplatních páskách
apps/frappe/frappe/utils/__init__.py +85,{0} is not a valid email id,{0} není platné id emailu
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: ToDo,Low,Nízké
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +70,Spinning,Spinning
DocType: Landed Cost Voucher,Landed Cost Voucher,Přistálo Náklady Voucher
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.py +55,Please set {0},Prosím nastavte {0}
DocType: Purchase Invoice,Repeat on Day of Month,Opakujte na den v měsíci
DocType: Employee,Health Details,Zdravotní Podrobnosti
DocType: Offer Letter,Offer Letter Terms,Nabídka Letter Podmínky
DocType: Features Setup,To track any installation or commissioning related work after sales,Chcete-li sledovat jakékoli zařízení nebo uvedení do provozu souvisejících s prací po prodeji
DocType: Project,Estimated Costing,Odhadovaná kalkulace
DocType: Purchase Invoice Advance,Journal Entry Detail No,Zápis do deníku Detail No
DocType: Employee External Work History,Salary,Plat
DocType: Serial No,Delivery Document Type,Dodávka Typ dokumentu
DocType: Salary Manager,Submit all salary slips for the above selected criteria,Odeslat všechny výplatní pásky pro výše zvolených kritérií
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +93,{0} Items synced,{0} položky synchronizovány
DocType: Sales Order,Partly Delivered,Částečně vyhlášeno
DocType: Sales Invoice,Existing Customer,Stávající zákazník
DocType: Email Digest,Receivables,Pohledávky
DocType: Quality Inspection Reading,Reading 5,Čtení 5
DocType: Purchase Order,"Enter email id separated by commas, order will be mailed automatically on particular date","Zadejte e-mail id odděleny čárkami, bude objednávka bude zaslán automaticky na určité datum"
apps/erpnext/erpnext/crm/doctype/lead/lead.py +37,Campaign Name is required,Je zapotřebí Název kampaně
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Rounded Off,Zaokrouhleno
DocType: Maintenance Visit,Maintenance Date,Datum údržby
DocType: Purchase Receipt Item,Rejected Serial No,Zamítnuto Serial No
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +50,Deep drawing,Hluboké tažení
apps/erpnext/erpnext/selling/doctype/sales_bom/sales_bom.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Prosím, vyberte položku, kde ""je skladem"", je ""Ne"" a ""Je Sales Item"" ""Ano"" a není tam žádný jiný Sales BOM"
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 +167,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 +46,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 +143,BOM and Manufacturing Quantity are required,BOM a výroba množství jsou povinné
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Stárnutí rozsah 2
DocType: Journal Entry Account,Amount,Částka
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +146,Riveting,Nýtování
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,Výrobní nastavení
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr
DocType: Stock Entry Detail,Stock Entry Detail,Reklamní Entry Detail
apps/erpnext/erpnext/templates/includes/cart.js +286,You need to be logged in to view your cart.,Musíte být přihlášen k zobrazení košíku.
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +200,New Account Name,Nový název účtu
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Dodává se nákladů na suroviny
DocType: Selling Settings,Settings for Selling Module,Nastavení pro prodej Module
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +68,Customer Service,Služby zákazníkům
DocType: Item Customer Detail,Item Customer Detail,Položka Detail Zákazník
apps/erpnext/erpnext/config/hr.py +53,Offer candidate a Job.,Nabídka kandidát Job.
DocType: Notification Control,Prompt for Email on Submission of,Výzva pro e-mail na předkládání
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +61,Item {0} must be a stock Item,Položka {0} musí být skladem
apps/erpnext/erpnext/config/accounts.py +102,Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
apps/frappe/frappe/model/naming.py +40,{0} is required,{0} je vyžadováno
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +20,Vacuum molding,Vakuové tváření
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +57,Expected Date cannot be before Material Request Date,Očekávané datum nemůže být před Materiál Poptávka Datum
DocType: Contact Us Settings,City,Město
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +131,Ultrasonic machining,Ultrazvukové obrábění
apps/erpnext/erpnext/stock/get_item_details.py +126,Item {0} must be a Sales Item,Bod {0} musí být prodejní položky
DocType: Naming Series,Update Series Number,Aktualizace Series Number
DocType: Account,Equity,Hodnota majetku
DocType: Task,Closing Date,Uzávěrka Datum
DocType: Sales Order Item,Produced Quantity,Produkoval Množství
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +79,Engineer,Inženýr
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +329,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: Purchase Order,% of materials received against this Purchase Order,% materiálů přijatých proti této objednávce
DocType: Authorization Rule,Customerwise Discount,Sleva podle zákazníka
DocType: Purchase Invoice,Against Expense Account,Proti výdajového účtu
DocType: Production Order,Production Order,Výrobní Objednávka
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +242,Installation Note {0} has already been submitted,Poznámka k instalaci {0} již byla odeslána
DocType: Quotation Item,Against Docname,Proti Docname
DocType: SMS Center,All Employee (Active),Všichni zaměstnanci (Aktivní)
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Zobrazit nyní
DocType: Purchase Invoice,Select the period when the invoice will be generated automatically,"Vyberte období, kdy faktura budou generovány automaticky"
DocType: BOM,Raw Material Cost,Cena surovin
DocType: Item Reorder,Re-Order Level,Re-Order Level
DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,"Zadejte položky a plánované ks, pro které chcete získat zakázky na výrobu, nebo stáhnout suroviny pro analýzu."
sites/assets/js/list.min.js +160,Gantt Chart,Pruhový diagram
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +52,Part-time,Part-time
DocType: Employee,Applicable Holiday List,Použitelný Seznam Svátků
DocType: Employee,Cheque,Šek
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +52,Series Updated,Řada Aktualizováno
apps/erpnext/erpnext/accounts/doctype/account/account.py +105,Report Type is mandatory,Report Type je povinné
DocType: Item,Serial Number Series,Sériové číslo Series
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +67,Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný pro skladovou položku {0} na řádku {1}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +44,Retail & Wholesale,Maloobchod a velkoobchod
DocType: Issue,First Responded On,Prvně odpovězeno dne
DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Výpis zboží v několika skupinách
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +349,The First User: You,První Uživatel: Vy
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +48,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Datum zahájení a  Datum ukončení Fiskálního roku jsou již stanoveny ve fiskálním roce {0}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Successfully Reconciled,Úspěšně smířeni
DocType: Production Order,Planned End Date,Plánované datum ukončení
apps/erpnext/erpnext/config/stock.py +43,Where items are stored.,"Tam, kde jsou uloženy předměty."
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +19,Invoiced Amount,Fakturovaná částka
DocType: Attendance,Attendance,Účast
DocType: Page,No,Ne
DocType: BOM,Materials,Materiály
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Pokud není zatrženo, seznam bude muset být přidány ke každé oddělení, kde má být použit."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +663,Make Delivery,Proveďte Dodávka
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +261,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."
DocType: Period Closing Voucher,Period Closing Voucher,Období Uzávěrka Voucher
apps/erpnext/erpnext/config/stock.py +125,Price List master.,Ceník master.
DocType: Task,Review Date,Review Datum
DocType: DocPerm,Level,Úroveň
DocType: Purchase Taxes and Charges,On Net Total,On Net Celkem
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +176,Target warehouse in row {0} must be same as Production Order,Target sklad v řádku {0} musí být stejná jako výrobní zakázky
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +61,No permission to use Payment Tool,Nemáte oprávnění k použití platební nástroj
apps/erpnext/erpnext/controllers/recurring_document.py +191,'Notification Email Addresses' not specified for recurring %s,"""E-mailové adresy pro Oznámení"", které nejsou uvedeny na opakující se %s"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +85,Milling,Frézování
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +59,Nibbling,Okusování
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +84,Administrative Expenses,Administrativní náklady
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +17,Consulting,Consulting
DocType: Customer Group,Parent Customer Group,Parent Customer Group
sites/assets/js/erpnext.min.js +45,Change,Změna
DocType: Purchase Invoice,Contact Email,Kontaktní e-mail
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +103,Purchase Order {0} is 'Stopped',Vydaná objednávka {0} je 'Zastavena'
DocType: Appraisal Goal,Score Earned,Skóre Zasloužené
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +391,"e.g. ""My Company LLC""","např ""My Company LLC """
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +168,Notice Period,Výpovědní Lhůta
DocType: Bank Reconciliation Detail,Voucher ID,Voucher ID
apps/erpnext/erpnext/setup/doctype/territory/territory.js +14,This is a root territory and cannot be edited.,To je kořen území a nelze upravovat.
DocType: Packing Slip,Gross Weight UOM,Hrubá Hmotnost UOM
DocType: Email Digest,Receivables / Payables,Pohledávky / Závazky
DocType: Journal Entry Account,Against Sales Invoice,Proti prodejní faktuře
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +62,Stamping,Lisování
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
DocType: Item,Default Warehouse,Výchozí Warehouse
DocType: Task,Actual End Date (via Time Logs),Skutečné Datum ukončení (přes Time Záznamy)
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +20,Please enter parent cost center,"Prosím, zadejte nákladové středisko mateřský"
DocType: Delivery Note,Print Without Amount,Tisknout bez Částka
apps/erpnext/erpnext/controllers/buying_controller.py +70,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Daň z kategorie nemůže být ""Ocenění"" nebo ""Ocenění a celkový"", protože všechny položky jsou běžně skladem"
DocType: User,Last Name,Příjmení
DocType: Web Page,Left,Vlevo
DocType: Event,All Day,Celý den
DocType: Communication,Support Team,Tým podpory
DocType: Appraisal,Total Score (Out of 5),Celkové skóre (Out of 5)
DocType: Contact Us Settings,State,Stav
DocType: Batch,Batch,Šarže
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +48,Balance,Zůstatek
DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nároků)
DocType: User,Gender,Pohlaví
DocType: Journal Entry,Debit Note,Debit Note
DocType: Stock Entry,As per Stock UOM,Podle Stock nerozpuštěných
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Neuplynula
DocType: Journal Entry,Total Debit,Celkem Debit
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Sales Person,Prodej Osoba
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +496,Unstop Purchase Order,Uvolnit Objednávka
DocType: Sales Invoice,Cold Calling,Cold Calling
DocType: SMS Parameter,SMS Parameter,SMS parametrů
DocType: Maintenance Schedule Item,Half Yearly,Pololetní
DocType: Lead,Blog Subscriber,Blog Subscriber
DocType: Email Digest,Income Year to Date,Rok příjmů do dneška
apps/erpnext/erpnext/config/setup.py +58,Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Pokud je zaškrtnuto, Total no. pracovních dnů bude zahrnovat dovolenou, a to sníží hodnotu platu za každý den"
DocType: Purchase Invoice,Total Advance,Total Advance
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +543,Unstop Material Request,Uvolnit materiálu Poptávka
DocType: Workflow State,User,Uživatel
DocType: Opportunity Item,Basic Rate,Basic Rate
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +122,Set as Lost,Nastavit jako Lost
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +57,Stock balances updated,Stock zůstatky aktualizováno
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +427,Cannot return more than {0} for Item {1},Nelze vrátit více než {0} položky {1}
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovních hodin.
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +91,{0} {1} has already been submitted,{0} {1} již byla odeslána
,Items To Be Requested,Položky se budou vyžadovat
DocType: Purchase Order,Get Last Purchase Rate,Získejte posledního nákupu Cena
DocType: Company,Company Info,Společnost info
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +75,Seaming,Sešívání
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +194,"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
DocType: Fiscal Year,Year Start Date,Datum Zahájení Roku
DocType: Attendance,Employee Name,Jméno zaměstnance
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +241,Debit To account must be a liability account,"Debetní Chcete-li v úvahu, musí být účet závazek"
DocType: Sales Invoice,Rounded Total (Company Currency),Zaoblený Total (Company Měna)
apps/erpnext/erpnext/accounts/doctype/account/account.py +89,Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
DocType: Purchase Common,Purchase Common,Nákup Common
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +93,{0} {1} has been modified. Please refresh.,{0} {1} byl změněn. Prosím aktualizujte.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Přestaňte uživatelům provádět Nechat aplikací v následujících dnech.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +626,From Opportunity,Od Opportunity
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +45,Blanking,Zaclonění
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +161,Employee Benefits,Zaměstnanecké benefity
DocType: Sales Invoice,Is POS,Je POS
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +224,Packed quantity must equal quantity for Item {0} in row {1},Balíčky množství se musí rovnat množství pro položku {0} v řadě {1}
DocType: Production Order,Manufactured Qty,Vyrobeno Množství
DocType: Purchase Receipt Item,Accepted Quantity,Schválené Množství
apps/erpnext/erpnext/config/accounts.py +18,Bills raised to Customers.,Směnky vznesené zákazníkům.
DocType: DocField,Default,Výchozí
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID projektu
DocType: Item,"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Výběrem ""Yes"" umožní tato položka se objeví v objednávce, a doklad o zaplacení."
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.py +41,{0} subscribers added,{0} odběratelé z přidané
DocType: Maintenance Schedule,Schedule,Plán
DocType: Account,Parent Account,Nadřazený účet
DocType: Serial No,Available,K dispozici
DocType: Quality Inspection Reading,Reading 3,Čtení 3
,Hub,Hub
DocType: GL Entry,Voucher Type,Voucher Type
DocType: Expense Claim,Approved,Schválený
DocType: Pricing Rule,Price,Cena
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +79,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
DocType: Address,Office,Kancelář
apps/frappe/frappe/desk/moduleview.py +67,Standard Reports,Standardní výpisy
apps/erpnext/erpnext/config/accounts.py +13,Accounting journal entries.,Zápisy v účetním deníku.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +210,Please select Employee Record first.,"Prosím, vyberte zaměstnance záznam první."
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 +227,Please enter Expense Account,"Prosím, zadejte výdajového účtu"
DocType: Account,Stock,Sklad
DocType: Employee,Current Address,Aktuální adresa
DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Je-li položka je varianta další položku pak popis, obraz, oceňování, daní atd bude stanoven ze šablony, pokud není výslovně uvedeno"
DocType: Serial No,Purchase / Manufacture Details,Nákup / Výroba Podrobnosti
DocType: Employee,Contract End Date,Smlouva Datum ukončení
DocType: Sales Order,Track this Sales Order against any Project,Sledovat tento prodejní objednávky na jakýkoli projekt
apps/erpnext/erpnext/templates/includes/cart.js +284,Price List not configured.,Ceník není nakonfigurován.
DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,"Prodejní Pull zakázky (čeká dodat), na základě výše uvedených kritérií"
DocType: DocShare,Document Type,Typ dokumentu
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +558,From Supplier Quotation,Z nabídky dodavatele
DocType: Deduction Type,Deduction Type,Odpočet Type
DocType: Attendance,Half Day,Půl den
DocType: Serial No,Not Available,Není k dispozici
DocType: Pricing Rule,Min Qty,Min Množství
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 +92,Total Tax,Total Tax
DocType: Stock Entry,Default Target Warehouse,Výchozí Target Warehouse
DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Company Měna)
DocType: Notification Control,Purchase Receipt Message,Zpráva příjemky
DocType: Production Order,Actual Start Date,Skutečné datum zahájení
DocType: Sales Order,% of materials delivered against this Sales Order,% Materiálů doručeno proti tomuto odběrateli
apps/erpnext/erpnext/config/stock.py +18,Record item movement.,Záznam pohybu položka.
DocType: Newsletter List Subscriber,Newsletter List Subscriber,Newsletter seznamu účastníků
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +163,Morticing,Dlabačky
DocType: Email Account,Service,Služba
DocType: Hub Settings,Hub Settings,Nastavení Hub
DocType: Project,Gross Margin %,Hrubá Marže %
DocType: BOM,With Operations,S operacemi
,Monthly Salary Register,Měsíční plat Register
apps/frappe/frappe/website/template.py +120,Next,Další
DocType: Warranty Claim,If different than customer address,Pokud se liší od adresy zákazníka
DocType: BOM Operation,BOM Operation,BOM Operation
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +117,Electropolishing,Elektrolytické
DocType: Purchase Taxes and Charges,On Previous Row Amount,Na předchozí řady Částka
DocType: Email Digest,New Delivery Notes,Nové dodací listy
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +30,Please enter Payment Amount in atleast one row,"Prosím, zadejte částku platby aspoň jedné řadě"
apps/erpnext/erpnext/templates/pages/tickets.py +34,Please write something in subject and message!,"Prosím, napište něco do předmětu zprávy a poselství!"
apps/erpnext/erpnext/config/accounts.py +143,"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +190,Row {0}: Payment Amount cannot be greater than Outstanding Amount,Row {0}: Platba Částka nesmí být vyšší než dlužná částka
apps/erpnext/erpnext/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 +129,"Item {0} is a template, please select one of its variants","Položka {0} je šablona, ​​prosím vyberte jednu z jeho variant"
DocType: System Settings,Localization,Lokalizace
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +74,Net pay cannot be negative,Net plat nemůže být záporný
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +70,Please enter the Against Vouchers manually,Zadejte prosím podle dokladů ručně
DocType: SMS Settings,Static Parameters,Statické parametry
DocType: Purchase Order,Advance Paid,Vyplacené zálohy
DocType: Item,Item Tax,Daň Položky
DocType: Expense Claim,Employees Email Id,Zaměstnanci Email Id
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +159,Current Liabilities,Krátkodobé závazky
apps/erpnext/erpnext/config/crm.py +43,Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Zvažte daň či poplatek za
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +53,Actual Qty is mandatory,Skutečné Množství je povinné
DocType: Item,"Select ""Yes"" if you are maintaining stock of this item in your Inventory.","Zvolte ""Ano"", pokud se udržuje zásoby této položky ve vašem inventáři."
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +415,Item {0} does not exist in {1} {2},Bod {0} neexistuje v {1} {2}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +41,Cross-rolling,Cross-válcování
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +127,Credit Card,Kreditní karta
DocType: BOM,Item to be manufactured or repacked,Položka být vyráběn nebo znovu zabalena
apps/erpnext/erpnext/config/stock.py +95,Default settings for stock transactions.,Výchozí nastavení pro akciových transakcí.
DocType: Purchase Invoice,Next Date,Další data
DocType: Employee Education,Major/Optional Subjects,Hlavní / Volitelné předměty
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +49,Please enter Taxes and Charges,"Prosím, zadejte Daně a poplatky"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +84,Machining,Obrábění
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Zde si můžete udržovat rodinné detailů, jako jsou jméno a povolání rodičem, manželem a dětmi"
DocType: Hub Settings,Seller Name,Prodejce Name
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Daně a poplatky odečteny (Company měna)
DocType: Item Group,General Settings,Obecné nastavení
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +19,From Currency and To Currency cannot be same,Z měny a měny nemůže být stejné
DocType: Stock Entry,Repack,Přebalit
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Musíte Uložte formulář před pokračováním
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +480,Attach Logo,Připojit Logo
DocType: Customer,Commission Rate,Výše provize
apps/erpnext/erpnext/config/hr.py +145,Block leave applications by department.,Aplikace Block dovolené podle oddělení.
DocType: Production Order,Actual Operating Cost,Skutečné provozní náklady
apps/erpnext/erpnext/accounts/doctype/account/account.py +55,Root cannot be edited.,Root nelze upravovat.
apps/erpnext/erpnext/accounts/utils.py +188,Allocated amount can not greater than unadusted amount,Přidělená částka nemůže vyšší než částka unadusted
DocType: Manufacturing Settings,Allow Production on Holidays,Povolit Výrobu při dovolené
DocType: Sales Order,Customer's Purchase Order Date,Zákazníka Objednávka Datum
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +183,Capital Stock,Základní kapitál
DocType: Packing Slip,Package Weight Details,Hmotnost balení Podrobnosti
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +105,Please select a csv file,Vyberte soubor csv
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +89,Designer,Návrhář
apps/erpnext/erpnext/config/selling.py +116,Terms and Conditions Template,Podmínky Template
DocType: Serial No,Delivery Details,Zasílání
DocType: Party Type,Allow Children,Povolit děti
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +362,Cost Center is required in row {0} in Taxes table for type {1},Nákladové středisko je nutné v řadě {0} na daních tabulka typu {1}
DocType: Purchase Invoice Item,Discount %,Sleva%
,Item-wise Purchase Register,Item-moudrý Nákup Register
DocType: Batch,Expiry Date,Datum vypršení platnosti
,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.,Nevykazují žádný symbol jako $ atd vedle měnám.
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 +496,Get Items from BOM,Získat předměty z BOM
DocType: Item,Lead Time Days,Dodací lhůta dny
DocType: Backup Manager,Send Notifications To,Odeslat upozornění
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html +26,Ref Date,Ref Datum
DocType: Employee,Reason for Leaving,Důvod Leaving
DocType: Expense Claim Detail,Sanctioned Amount,Sankcionována Částka
DocType: GL Entry,Is Opening,Se otevírá
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +188,Row {0}: Debit entry can not be linked with a {1},Row {0}: záporný nemůže být spojována s {1}
apps/erpnext/erpnext/accounts/doctype/account/account.py +160,Account {0} does not exist,Účet {0} neexistuje
DocType: Account,Cash,V hotovosti
DocType: Employee,Short biography for website and other publications.,Krátký životopis na internetové stránky a dalších publikací.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +31,Please create Salary Structure for employee {0},Prosím vytvořte platovou strukturu pro zaměstnance {0}
