DocType: Employee,Salary Mode,Mode Plat
DocType: Employee,Divorced,Rozvedený
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +96,Items already synced,Položky již synchronizovat
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,"Povoliť položky, ktoré sa pridávajú viackrát v transakcii"
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Materiál Navštivte {0} před zrušením této záruční reklamaci Zrušit
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +19,Consumer Products,Zákaznícke produkty
DocType: Supplier Scorecard,Notify Supplier,Informujte dodávateľa
DocType: Item,Customer Items,Zákazník položky
DocType: Project,Costing and Billing,Kalkulácia a fakturácia
apps/erpnext/erpnext/accounts/doctype/account/account.py +52,Account {0}: Parent account {1} can not be a ledger,Účet {0}: Nadřazený účet {1} nemůže být hlavní kniha
DocType: Item,Publish Item to hub.erpnext.com,Publikování položku do hub.erpnext.com
apps/erpnext/erpnext/config/setup.py +88,Email Notifications,E-mailová upozornění
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,ohodnotenie
DocType: Item,Default Unit of Measure,Predvolená merná jednotka
DocType: SMS Center,All Sales Partner Contact,Všechny Partneři Kontakt
DocType: Employee,Leave Approvers,Schvaľovatelia priepustiek
DocType: Sales Partner,Dealer,Dealer
DocType: Employee,Rented,Pronajato
DocType: Purchase Order,PO-,NO-
DocType: POS Profile,Applicable for User,Použiteľné pre Užívateľa
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +196,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Zastavil výrobu Objednať nemožno zrušiť, uvoľniť ho najprv zrušiť"
DocType: Vehicle Service,Mileage,Najazdené
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +231,Do you really want to scrap this asset?,Naozaj chcete zrušiť túto pohľadávku?
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Vybrať Predvolené Dodávateľ
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Měna je vyžadováno pro Ceníku {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Bude vypočítané v transakcii.
DocType: Purchase Order,Customer Contact,Zákaznícky kontakt
DocType: Job Applicant,Job Applicant,Job Žadatel
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,To je založené na transakciách proti tomuto dodávateľovi. Pozri časovú os nižšie podrobnosti
apps/erpnext/erpnext/hub_node/page/hub/hub_body.html +18,No more results.,Žádné další výsledky.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +34,Legal,Právne
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Actual type tax cannot be included in Item rate in row {0},Aktuálny typ daň nemôže byť zahrnutý v cene Položka v riadku {0}
DocType: Bank Guarantee,Customer,Zákazník
DocType: Purchase Receipt Item,Required By,Vyžadováno
DocType: Delivery Note,Return Against Delivery Note,Návrat Proti dodací list
DocType: Purchase Order,% Billed,% Fakturovaných
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Exchange Rate musí byť rovnaká ako {0} {1} ({2})
DocType: Sales Invoice,Customer Name,Meno zákazníka
DocType: Vehicle,Natural Gas,Zemný plyn
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +132,Bank account cannot be named as {0},Bankový účet nemôže byť pomenovaný {0}
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,"Heads (nebo skupiny), proti nimž účetní zápisy jsou vyrobeny a stav je veden."
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Vynikající pro {0} nemůže být nižší než nula ({1})
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +357,There are no submitted Salary Slips to process.,Neexistujú žiadne predložené platobné klacky na spracovanie.
DocType: Manufacturing Settings,Default 10 mins,Predvolené 10 min
DocType: Leave Type,Leave Type Name,Nechte Typ Jméno
apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,ukázať otvorené
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Řada Aktualizováno Úspěšně
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Odhlásiť sa
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +175,Accural Journal Entry Submitted,Accural Journal Entry Vložené
DocType: Pricing Rule,Apply On,Naneste na
DocType: Item Price,Multiple Item prices.,Více ceny položku.
,Purchase Order Items To Be Received,Neprijaté položky odoslanej objednávky
DocType: SMS Center,All Supplier Contact,Vše Dodavatel Kontakt
DocType: Support Settings,Support Settings,nastavenie podporných
apps/erpnext/erpnext/projects/doctype/project/project.py +65,Expected End Date can not be less than Expected Start Date,"Očakávané Dátum ukončenia nemôže byť nižšia, než sa očakávalo dáta začatia"
apps/erpnext/erpnext/utilities/transaction_base.py +110,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,"Riadok # {0}: Cena musí byť rovnaké, ako {1}: {2} ({3} / {4})"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,New Leave Application
,Batch Item Expiry Status,Batch Item Zánik Status
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +153,Bank Draft,Bank Návrh
DocType: Mode of Payment Account,Mode of Payment Account,Způsob platby účtu
apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Zobraziť Varianty
DocType: Academic Term,Academic Term,akademický Term
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Materiál
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +670,Quantity,Množstvo
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Účty tabuľka nemôže byť prázdne.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Úvěry (závazky)
DocType: Employee Education,Year of Passing,Rok Passing
DocType: Item,Country of Origin,Krajina pôvodu
apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,Na skladě
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,otvorené problémy
DocType: Production Plan Item,Production Plan Item,Výrobní program Item
apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,User {0} is already assigned to Employee {1},Uživatel {0} je již přiřazena k Employee {1}
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +31,Health Care,Péče o zdraví
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Oneskorenie s platbou (dni)
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,service Expense
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +870,Serial Number: {0} is already referenced in Sales Invoice: {1},Sériové číslo: {0} už je uvedené vo faktúre predaja: {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +824,Invoice,Faktúra
DocType: Maintenance Schedule Item,Periodicity,Periodicita
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Fiškálny rok {0} je vyžadovaná
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +21,Defense,Obrana
DocType: Salary Component,Abbr,Zkr
DocType: Appraisal Goal,Score (0-5),Score (0-5)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225,Row {0}: {1} {2} does not match with {3},Řádek {0}: {1} {2} se neshoduje s {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +75,Row # {0}:,Řádek # {0}:
DocType: Timesheet,Total Costing Amount,Celková kalkulácie Čiastka
DocType: Delivery Note,Vehicle No,Vozidle
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +154,Please select Price List,"Prosím, vyberte cenník"
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Riadok # {0}: Platba dokument je potrebné na dokončenie trasaction
DocType: Production Order Operation,Work In Progress,Work in Progress
apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +13,Please select date,"Prosím, vyberte dátum"
DocType: Employee,Holiday List,Dovolená Seznam
apps/erpnext/erpnext/public/js/setup_wizard.js +216,Accountant,Účtovník
DocType: Cost Center,Stock User,Používateľ skladu
DocType: Company,Phone No,Telefónne číslo
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +50,Course Schedules created:,Plány kurzu vytvoril:
apps/erpnext/erpnext/controllers/recurring_document.py +135,New {0}: #{1},Nový {0}: # {1}
,Sales Partners Commission,Obchodní partneři Komise
apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Skratka nesmie mať viac ako 5 znakov
DocType: Payment Request,Payment Request,Platba Dopyt
DocType: Asset,Value After Depreciation,Hodnota po odpisoch
DocType: Employee,O+,O +
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +17,Related,príbuzný
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,Dátum návštevnosť nemôže byť nižšia ako spojovacie dáta zamestnanca
DocType: Grading Scale,Grading Scale Name,Stupnica Name
apps/erpnext/erpnext/accounts/doctype/account/account.js +41,This is a root account and cannot be edited.,To je kořen účtu a nelze upravovat.
DocType: Sales Invoice,Company Address,Adresa spoločnosti
DocType: BOM,Operations,Operace
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Nelze nastavit oprávnění na základě Sleva pro {0}
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Pripojiť CSV súbor s dvomi stĺpci, jeden pre starý názov a jeden pre nový názov"
apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} žiadnym aktívnym fiškálny rok.
DocType: Packed Item,Parent Detail docname,Parent Detail docname
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Odkaz: {0}, Kód položky: {1} a zákazník: {2}"
apps/erpnext/erpnext/public/js/setup_wizard.js +310,Kg,Kg
DocType: Student Log,Log,log
apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Otevření o zaměstnání.
DocType: Item Attribute,Increment,Prírastok
apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Vyberte sklad ...
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +6,Advertising,Reklama
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Rovnaký Spoločnosť je zapísaná viac ako raz
DocType: Employee,Married,Ženatý
apps/erpnext/erpnext/accounts/party.py +44,Not permitted for {0},Nepovolené pre {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +568,Get items from,Získať predmety z
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +455,Stock cannot be updated against Delivery Note {0},Sklad nelze aktualizovat na dodací list {0}
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produkt {0}
apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Nie sú uvedené žiadne položky
DocType: Payment Reconciliation,Reconcile,Srovnat
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,Potraviny
DocType: Quality Inspection Reading,Reading 1,Čtení 1
DocType: Process Payroll,Make Bank Entry,Proveďte Bank Vstup
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +40,Pension Funds,Penzijní fondy
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Vedľa Odpisy dátum nemôže byť pred nákupom Dátum
DocType: SMS Center,All Sales Person,Všichni obchodní zástupci
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,"** Mesačný Distribúcia ** umožňuje distribuovať Rozpočet / Target celé mesiace, ak máte sezónnosti vo vašej firme."
apps/erpnext/erpnext/accounts/page/pos/pos.js +1691,Not items found,nenájdený položiek
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +181,Salary Structure Missing,Plat Štruktúra Chýbajúce
DocType: Lead,Person Name,Osoba Meno
DocType: Sales Invoice Item,Sales Invoice Item,Prodejní faktuře položka
DocType: Account,Credit,Úvěr
DocType: POS Profile,Write Off Cost Center,Odepsat nákladové středisko
apps/erpnext/erpnext/public/js/setup_wizard.js +99,"e.g. ""Primary School"" or ""University""",napríklad &quot;Základná škola&quot; alebo &quot;univerzita&quot;
apps/erpnext/erpnext/config/stock.py +32,Stock Reports,Reporty o zásobách
DocType: Warehouse,Warehouse Detail,Sklad Detail
apps/erpnext/erpnext/selling/doctype/customer/customer.py +161,Credit limit has been crossed for customer {0} {1}/{2},Úvěrový limit byla překročena o zákazníka {0} {1} / {2}
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termínovaný Dátum ukončenia nemôže byť neskôr ako v roku Dátum ukončenia akademického roka, ku ktorému termín je spojená (akademický rok {}). Opravte dáta a skúste to znova."
apps/erpnext/erpnext/stock/doctype/item/item.py +467,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Je Fixed Asset&quot; nemôže byť bez povšimnutia, pretože existuje Asset záznam proti položke"
DocType: Vehicle Service,Brake Oil,Brake Oil
DocType: Tax Rule,Tax Type,Typ dane
apps/erpnext/erpnext/controllers/taxes_and_totals.py +552,Taxable Amount,Zdaniteľná čiastka
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Nejste oprávněni přidávat nebo aktualizovat údaje před {0}
DocType: BOM,Item Image (if not slideshow),Item Image (ne-li slideshow)
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) * Skutočná Prevádzková doba
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1048,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Riadok # {0}: Typ referenčného dokumentu musí byť jeden z nárokov na výdaj alebo denníka
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +907,Select BOM,select BOM
DocType: SMS Log,SMS Log,SMS Log
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Náklady na dodávaných výrobků
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Dovolenka na {0} nie je medzi Dátum od a do dnešného dňa
DocType: Student Log,Student Log,študent Log
DocType: Quality Inspection,Get Specification Details,Získat Specifikace Podrobnosti
apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Šablóny poradia dodávateľov.
DocType: Lead,Interested,Zájemci
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +171,Opening,Otvor
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +28,From {0} to {1},Od {0} do {1}
DocType: Item,Copy From Item Group,Kopírovat z bodu Group
DocType: Journal Entry,Opening Entry,Otevření Entry
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Účet Pay Iba
DocType: Employee Loan,Repay Over Number of Periods,Splatiť Over počet období
DocType: Stock Entry,Additional Costs,Dodatočné náklady
apps/erpnext/erpnext/accounts/doctype/account/account.py +141,Account with existing transaction can not be converted to group.,Účet s transakcemi nelze převést na skupinu.
apps/erpnext/erpnext/schools/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in School &gt; School Settings,"Prosím, nastavte názov inštruktora do školy&gt; Školské nastavenia"
DocType: Lead,Product Enquiry,Dotaz Product
DocType: Academic Term,Schools,školy
DocType: School Settings,Validate Batch for Students in Student Group,Overenie dávky pre študentov v študentskej skupine
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Žiadny záznam dovolenka nájdené pre zamestnancov {0} na {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,"Prosím, najprv zadajte spoločnosť"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +358,Please select Company first,"Prosím, vyberte najprv firmu"
DocType: Employee Education,Under Graduate,Za absolventa
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Target On
DocType: BOM,Total Cost,Celkové náklady
DocType: Journal Entry Account,Employee Loan,Pôžička zamestnanca
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +108,Activity Log:,Aktivita Log:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +245,Item {0} does not exist in the system or has expired,Bod {0} neexistuje v systému nebo vypršela
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +44,Real Estate,Nemovitost
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Výpis z účtu
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +41,Pharmaceuticals,Farmaceutické
DocType: Purchase Invoice Item,Is Fixed Asset,Je dlhodobého majetku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +234,"Available qty is {0}, you need {1}","K dispozícii je množstvo {0}, musíte {1}"
DocType: Expense Claim Detail,Claim Amount,Nárok Částka
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +51,Duplicate customer group found in the cutomer group table,Duplicitné skupinu zákazníkov uvedené v tabuľke na knihy zákazníkov skupiny
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Dodavatel Typ / dovozce
DocType: Naming Series,Prefix,Prefix
apps/erpnext/erpnext/public/js/setup_wizard.js +307,Consumable,Spotrebný materiál
DocType: Employee,B-,B-
DocType: Upload Attendance,Import Log,Záznam importu
DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Vytiahnite Materiál Žiadosť typu Výroba na základe vyššie uvedených kritérií
DocType: Training Result Employee,Grade,stupeň
DocType: Sales Invoice Item,Delivered By Supplier,Dodáva sa podľa dodávateľa
DocType: SMS Center,All Contact,Vše Kontakt
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +895,Production Order already created for all items with BOM,Zákazková výroba už vytvorili u všetkých položiek s BOM
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +193,Annual Salary,Ročné Plat
DocType: Daily Work Summary,Daily Work Summary,Denná práca Súhrn
DocType: Period Closing Voucher,Closing Fiscal Year,Uzavření fiskálního roku
apps/erpnext/erpnext/accounts/party.py +357,{0} {1} is frozen,{0} {1} je zmrazený
apps/erpnext/erpnext/setup/doctype/company/company.py +139,Please select Existing Company for creating Chart of Accounts,Vyberte existujúci spoločnosti pre vytváranie účtový rozvrh
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Náklady na skladovanie
apps/erpnext/erpnext/stock/doctype/batch/batch.js +91,Select Target Warehouse,Vyberte položku Target Warehouse
apps/erpnext/erpnext/stock/doctype/batch/batch.js +91,Select Target Warehouse,Vyberte položku Target Warehouse
apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,"Prosím, zadajte Preferred Kontaktný e-mail"
DocType: Program Enrollment,School Bus,Školský autobus
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Journal Entry Account,Credit in Company Currency,Úverové spoločnosti v mene
DocType: Delivery Note,Installation Status,Stav instalace
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Chcete aktualizovať dochádzku? <br> Súčasná: {0} \ <br> Prítomných {1}
apps/erpnext/erpnext/controllers/buying_controller.py +323,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Schválené + Zamietnuté množstvo sa musí rovnať Prijatému množstvu pre položku {0}
DocType: Request for Quotation,RFQ-,RFQ-
DocType: Item,Supply Raw Materials for Purchase,Dodávky suroviny pre nákup
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +148,At least one mode of payment is required for POS invoice.,pre POS faktúru je nutná aspoň jeden spôsob platby.
DocType: Products Settings,Show Products as a List,Zobraziť produkty ako zoznam
DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
All dates and employee combination in the selected period will come in the template, with existing attendance records","Stáhněte si šablony, vyplňte potřebné údaje a přiložte upravený soubor.
 Všechny termíny a zaměstnanec kombinaci ve zvoleném období přijde v šabloně, se stávajícími evidence docházky"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +482,Item {0} is not active or end of life has been reached,"Bod {0} není aktivní, nebo byl dosažen konec života"
apps/erpnext/erpnext/public/js/setup_wizard.js +346,Example: Basic Mathematics,Príklad: Základné Mathematics
apps/erpnext/erpnext/controllers/accounts_controller.py +670,"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 +214,Settings for HR Module,Nastavenie modulu HR
DocType: SMS Center,SMS Center,SMS centrum
DocType: Sales Invoice,Change Amount,zmena Suma
DocType: BOM Update Tool,New BOM,New BOM
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +117,Please enter Delivery Date,Zadajte dátum doručenia
DocType: Depreciation Schedule,Make Depreciation Entry,Urobiť Odpisy Entry
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Typ požadavku
apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,Vytvoriť zamestnanca
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +14,Broadcasting,Vysílání
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +160,Execution,Provedení
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Podrobnosti o prováděných operací.
DocType: Serial No,Maintenance Status,Status Maintenance
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Dodávateľ je potrebná proti zaplatení účtu {2}
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Položky a Ceny
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Celkom hodín: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},"Od data by měla být v rámci fiskálního roku. Za předpokladu, že od data = {0}"
DocType: Customer,Individual,Individuální
DocType: Interest,Academics User,akademici Užívateľ
DocType: Cheque Print Template,Amount In Figure,Na obrázku vyššie
DocType: Employee Loan Application,Loan Info,pôžička Informácie
apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plán pro návštěvy údržby.
DocType: Supplier Scorecard Period,Supplier Scorecard Period,Termín dodacieho obdobia dodávateľa
DocType: POS Profile,Customer Groups,skupiny zákazníkov
apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Finančné výkazy
DocType: Guardian,Students,študenti
apps/erpnext/erpnext/config/selling.py +91,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 +79,Installation date cannot be before delivery date for Item {0},Datum Instalace nemůže být před datem dodání pro bod {0}
DocType: Pricing Rule,Discount on Price List Rate (%),Zľava z cenníkovej ceny (%)
DocType: Offer Letter,Select Terms and Conditions,Vyberte Podmienky
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +60,Out Value,limitu
DocType: Production Planning Tool,Sales Orders,Predajné objednávky
DocType: Purchase Taxes and Charges,Valuation,Ocenění
,Purchase Order Trends,Nákupní objednávka trendy
apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Žiadosť o cenovú ponuku je možné pristupovať kliknutím na nasledujúci odkaz
apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Přidělit listy za rok.
DocType: SG Creation Tool Course,SG Creation Tool Course,SG nástroj pre tvorbu ihriská
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +236,Insufficient Stock,nedostatočná Sklad
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Zakázať Plánovanie kapacít a Time Tracking
DocType: Email Digest,New Sales Orders,Nové Prodejní objednávky
DocType: Bank Guarantee,Bank Account,Bankový účet
DocType: Leave Type,Allow Negative Balance,Povolit záporný zůstatek
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Nemôžete odstrániť typ projektu &quot;Externé&quot;
DocType: Employee,Create User,vytvoriť užívateľa
DocType: Selling Settings,Default Territory,Výchozí Territory
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Televize
DocType: Production Order Operation,Updated via 'Time Log',"Aktualizováno přes ""Time Log"""
apps/erpnext/erpnext/controllers/taxes_and_totals.py +424,Advance amount cannot be greater than {0} {1},Množstvo vopred nemôže byť väčšia ako {0} {1}
DocType: Naming Series,Series List for this Transaction,Řada seznam pro tuto transakci
DocType: Company,Enable Perpetual Inventory,Povoliť trvalý inventár
DocType: Company,Default Payroll Payable Account,"Predvolené mzdy, splatnú Account"
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +51,Update Email Group,Aktualizácia e-Group
DocType: Sales Invoice,Is Opening Entry,Je vstupní otvor
DocType: Customer Group,Mention if non-standard receivable account applicable,Zmienka v prípade neštandardnej pohľadávky účet použiteľná
DocType: Course Schedule,Instructor Name,inštruktor Name
DocType: Supplier Scorecard,Criteria Setup,Nastavenie kritérií
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +179,For Warehouse is required before Submit,Pro Sklad je povinné před Odesláním
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Prijaté On
DocType: Sales Partner,Reseller,Reseller
DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.","Ak je zaškrtnuté, bude zahŕňať non-skladových položiek v materiáli požiadavky."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +24,Please enter Company,"Prosím, zadajte spoločnosť"
DocType: Delivery Note Item,Against Sales Invoice Item,Proti položce vydané faktury
,Production Orders in Progress,Zakázka na výrobu v Progress
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Čistý peňažný tok z financovania
apps/erpnext/erpnext/accounts/page/pos/pos.js +2270,"LocalStorage is full , did not save","Miestne úložisko je plná, nezachránil"
DocType: Lead,Address & Contact,Adresa a kontakt
DocType: Leave Allocation,Add unused leaves from previous allocations,Pridať nevyužité listy z predchádzajúcich prídelov
apps/erpnext/erpnext/controllers/recurring_document.py +230,Next Recurring {0} will be created on {1},Dalšie opakovanie {0} bude vytvorené dňa {1}
DocType: Sales Partner,Partner website,webové stránky Partner
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +105,Add Item,Pridať položku
apps/erpnext/erpnext/public/js/setup_wizard.js +267,Contact Name,Meno kontaktu
DocType: Course Assessment Criteria,Course Assessment Criteria,Hodnotiace kritériá kurz
DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Vytvoří výplatní pásku na výše uvedených kritérií.
DocType: POS Customer Group,POS Customer Group,POS Customer Group
DocType: Cheque Print Template,Line spacing for amount in words,riadkovanie za čiastku v slovách
DocType: Vehicle,Additional Details,Ďalšie podrobnosti
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Plán posudzovania:
apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Bez popisu
apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Žádost o koupi.
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,To je založené na časových výkazov vytvorených proti tomuto projektu
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +385,Net Pay cannot be less than 0,Čistý Pay nemôže byť nižšia ako 0
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Pouze vybraný Leave schvalovač může podat této dovolené aplikaci
apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Relieving Date must be greater than Date of Joining,Uvolnění Datum musí být větší než Datum spojování
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +201,Leaves per Year,Listy za rok
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Row {0}: Zkontrolujte ""Je Advance"" proti účtu {1}, pokud je to záloha záznam."
apps/erpnext/erpnext/stock/utils.py +212,Warehouse {0} does not belong to company {1},Sklad {0} nepatří ke společnosti {1}
DocType: Email Digest,Profit & Loss,Zisk & Strata
apps/erpnext/erpnext/public/js/setup_wizard.js +311,Litre,liter
DocType: Task,Total Costing Amount (via Time Sheet),Celková kalkulácie Čiastka (cez Time Sheet)
DocType: Item Website Specification,Item Website Specification,Položka webových stránek Specifikace
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +477,Leave Blocked,Nechte Blokováno
apps/erpnext/erpnext/stock/doctype/item/item.py +673,Item {0} has reached its end of life on {1},Položka {0} dosáhla konce své životnosti na {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +88,Bank Entries,bankový Príspevky
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +119,Annual,Roční
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Inventúrna položka
DocType: Stock Entry,Sales Invoice No,Prodejní faktuře č
DocType: Material Request Item,Min Order Qty,Min Objednané množství
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Študent Group Creation Tool ihrisko
DocType: Lead,Do Not Contact,Nekontaktujte
apps/erpnext/erpnext/public/js/setup_wizard.js +361,People who teach at your organisation,"Ľudia, ktorí vyučujú vo vašej organizácii"
DocType: Purchase 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/setup_wizard/install_fixtures.py +104,Software Developer,Software Developer
DocType: Item,Minimum Order Qty,Minimální objednávka Množství
DocType: Pricing Rule,Supplier Type,Dodavatel Type
DocType: Course Scheduling Tool,Course Start Date,Začiatok Samozrejme Dátum
,Student Batch-Wise Attendance,Študent Batch-Wise Účasť
DocType: POS Profile,Allow user to edit Rate,Umožňujú užívateľovi upravovať Cena
DocType: Item,Publish in Hub,Publikovat v Hub
DocType: Student Admission,Student Admission,študent Vstupné
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +693,Item {0} is cancelled,Položka {0} je zrušená
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +898,Material Request,Požiadavka na materiál
DocType: Bank Reconciliation,Update Clearance Date,Aktualizace Výprodej Datum
DocType: Item,Purchase Details,Nákupné podrobnosti
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +357,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Položka {0} nebol nájdený v &quot;suroviny dodanej&quot; tabuľky v objednávke {1}
DocType: Employee,Relation,Vztah
DocType: Shipping Rule,Worldwide Shipping,Celosvetovo doprava
DocType: Student Guardian,Mother,matka
apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Potvrzené objednávky od zákazníků.
DocType: Purchase Receipt Item,Rejected Quantity,Zamítnuto Množství
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/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Platba proti {0} {1} nemôže byť väčšia ako dlžnej čiastky {2}
DocType: Supplier,Address HTML,Adresa HTML
DocType: Lead,Mobile No.,Mobile No.
DocType: Maintenance Schedule,Generate Schedule,Generování plán
DocType: Purchase Invoice Item,Expense Head,Náklady Head
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +146,Please select Charge Type first,"Prosím, vyberte druh tarifu první"
DocType: Student Group Student,Student Group Student,Študent Skupina Student
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Najnovšie
DocType: Vehicle Service,Inspection,inšpekcia
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard_row_head.html +1, List ,zoznam
DocType: Supplier Scorecard Scoring Standing,Max Grade,Max stupeň
DocType: Email Digest,New Quotations,Nové Citace
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,"E-maily výplatnej páske, aby zamestnanci na základe prednostného e-mailu vybraného v zamestnaneckých"
DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,První Leave schvalovač v seznamu bude nastaven jako výchozí Leave schvalujícího
DocType: Tax Rule,Shipping County,Okres dodania
apps/erpnext/erpnext/config/desktop.py +158,Learn,Učenie
DocType: Asset,Next Depreciation Date,Vedľa Odpisy Dátum
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Náklady na činnosť na jedného zamestnanca
DocType: Accounts Settings,Settings for Accounts,Nastavenie Účtovníctva
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +646,Supplier Invoice No exists in Purchase Invoice {0},Dodávateľské faktúry No existuje vo faktúre {0}
apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Správa obchodník strom.
DocType: Job Applicant,Cover Letter,Sprievodný list
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Vynikajúci Šeky a vklady s jasnými
DocType: Item,Synced With Hub,Synchronizovány Hub
DocType: Vehicle,Fleet Manager,fleet manager
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +517,Row #{0}: {1} can not be negative for item {2},Riadok # {0}: {1} nemôže byť negatívne na {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +70,Wrong Password,Zlé Heslo
DocType: Item,Variant Of,Varianta
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +367,Completed Qty can not be greater than 'Qty to Manufacture',"Dokončené množství nemůže být větší než ""Množství do výroby"""
DocType: Period Closing Voucher,Closing Account Head,Závěrečný účet hlava
DocType: Employee,External Work History,Vnější práce History
apps/erpnext/erpnext/projects/doctype/task/task.py +99,Circular Reference Error,Kruhové Referenčné Chyba
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Meno Guardian1
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,"Ve slovech (export) budou viditelné, jakmile uložíte doručení poznámku."
DocType: Cheque Print Template,Distance from left edge,Vzdialenosť od ľavého okraja
apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} jednotiek [{1}] (# Form / bodu / {1}) bola nájdená v [{2}] (# Form / sklad / {2})
DocType: Lead,Industry,Průmysl
DocType: Employee,Job Profile,Job Profile
apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Toto je založené na transakciách s touto spoločnosťou. Viac informácií nájdete v časovej osi nižšie
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Upozornit e-mailem na tvorbu automatických Materiál Poptávka
DocType: Journal Entry,Multi Currency,Viac mien
DocType: Payment Reconciliation Invoice,Invoice Type,Typ faktúry
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +861,Delivery Note,Dodací list
apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Nastavenie Dane
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +131,Cost of Sold Asset,Náklady predaných aktív
apps/erpnext/erpnext/accounts/utils.py +345,Payment Entry has been modified after you pulled it. Please pull it again.,"Vstup Platba byla změněna poté, co ji vytáhl. Prosím, vytáhněte ji znovu."
apps/erpnext/erpnext/stock/doctype/item/item.py +436,{0} entered twice in Item Tax,{0} vložené dvakrát v Daňovej Položke
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +114,Summary for this week and pending activities,Zhrnutie pre tento týždeň a prebiehajúcim činnostiam
DocType: Student Applicant,Admitted,"pripustil,"
DocType: Workstation,Rent Cost,Rent Cost
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Suma po odpisoch
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Nadchádzajúce Udalosti v kalendári
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,Vyberte měsíc a rok
DocType: Employee,Company Email,E-mail spoločnosti
DocType: GL Entry,Debit Amount in Account Currency,Debetné Čiastka v mene účtu
DocType: Supplier Scorecard,Scoring Standings,Skóre bodov
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Hodnota objednávky
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Hodnota objednávky
apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Banka / Hotovostné operácie proti osobe alebo pre interný prevod
DocType: Shipping Rule,Valid for Countries,"Platí pre krajiny,"
apps/erpnext/erpnext/stock/doctype/item/item.js +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Tento bod je šablona a nemůže být použit v transakcích. Atributy položky budou zkopírovány do variant, pokud je nastaveno ""No Copy"""
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Celková objednávka Zvážil
apps/erpnext/erpnext/config/hr.py +234,"Employee designation (e.g. CEO, Director etc.).","Označení zaměstnanců (např CEO, ředitel atd.)."
apps/erpnext/erpnext/controllers/recurring_document.py +223,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: Course Scheduling Tool,Course Scheduling Tool,Samozrejme Plánovanie Tool
apps/erpnext/erpnext/controllers/accounts_controller.py +571,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Riadok # {0}: faktúry nemožno vykonať voči existujúcemu aktívu {1}
DocType: Item Tax,Tax Rate,Sadzba dane
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} už pridelené pre zamestnancov {1} na dobu {2} až {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Select Item,Vyberte položku
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +140,Purchase Invoice {0} is already submitted,Přijatá faktura {0} je již odeslána
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},"Row # {0}: Batch No musí byť rovnaké, ako {1} {2}"
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Previesť na non-Group
apps/erpnext/erpnext/config/stock.py +122,Batch (lot) of an Item.,Batch (lot) položky.
DocType: C-Form Invoice Detail,Invoice Date,Dátum fakturácie
DocType: GL Entry,Debit Amount,Debetné Suma
apps/erpnext/erpnext/accounts/party.py +246,There can only be 1 Account per Company in {0} {1},Tam môže byť len 1 účet na spoločnosti v {0} {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +402,Please see attachment,"Prosím, viz příloha"
DocType: Purchase Order,% Received,% Prijaté
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Vytvorenie skupiny študentov
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +21,Setup Already Complete!!,Nastavenie programu je už dokončené !!
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Výška úverovej poznámky
,Finished Goods,Hotové zboží
DocType: Delivery Note,Instructions,Instrukce
DocType: Quality Inspection,Inspected By,Zkontrolován
DocType: Maintenance Visit,Maintenance Type,Typ Maintenance
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +40,{0} - {1} is not enrolled in the Course {2},{0} - {1} nie je zapísaný do kurzu {2}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Pořadové číslo {0} není součástí dodávky Poznámka: {1}
apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
apps/erpnext/erpnext/public/js/utils/item_selector.js +12,Add Items,Pridať položky
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Položka Kontrola jakosti Parametr
DocType: Leave Application,Leave Approver Name,Meno schvaľovateľa priepustky
DocType: Depreciation Schedule,Schedule Date,Plán Datum
apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Zisk, rabaty a ostatné súčasti Plat"
DocType: Packed Item,Packed Item,Zabalená položka
apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Výchozí nastavení pro nákup transakcí.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Existuje Náklady aktivity pre zamestnancov {0} proti Typ aktivity - {1}
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Povinné pole - Získajte študentov z
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Povinné pole - Získajte študentov z
DocType: Program Enrollment,Enrolled courses,Zapísané kurzy
DocType: Program Enrollment,Enrolled courses,Zapísané kurzy
DocType: Currency Exchange,Currency Exchange,Směnárna
DocType: Asset,Item Name,Název položky
DocType: Authorization Rule,Approving User  (above authorized value),Schválenie užívateľa (nad oprávnenej hodnoty)
DocType: Email Digest,Credit Balance,Credit Balance
DocType: Employee,Widowed,Ovdovělý
DocType: Request for Quotation,Request for Quotation,Žiadosť o cenovú ponuku
DocType: Salary Slip Timesheet,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/page/pos/pos.js +1472,Create a new Customer,Vytvoriť nový zákazník
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Je-li více pravidla pro tvorbu cen i nadále přednost, jsou uživatelé vyzváni k nastavení priority pro vyřešení konfliktu."
apps/erpnext/erpnext/utilities/activation.py +88,Create Purchase Orders,vytvorenie objednávok
,Purchase Register,Nákup Register
DocType: Course Scheduling Tool,Rechedule,Rechedule
DocType: Landed Cost Item,Applicable Charges,Použitelné Poplatky
DocType: Workstation,Consumable Cost,Spotrebné náklady
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',"{0} ({1}), musí mať úlohu ""Schvalovateľ voľna"""
DocType: Purchase Receipt,Vehicle Date,Dátum Vehicle
DocType: Student Log,Medical,Lékařský
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +177,Reason for losing,Důvod ztráty
apps/erpnext/erpnext/crm/doctype/lead/lead.py +41,Lead Owner cannot be same as the Lead,Získateľ Obchodnej iniciatívy nemôže byť to isté ako Obchodná iniciatíva
apps/erpnext/erpnext/accounts/utils.py +351,Allocated amount can not greater than unadjusted amount,Pridelená suma nemôže väčšie ako množstvo neupravené
DocType: Announcement,Receiver,prijímač
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation je uzavřena v následujících dnech podle Prázdninový Seznam: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Príležitosti
DocType: Employee,Single,Slobodný/á
DocType: Salary Slip,Total Loan Repayment,celkové splátky
DocType: Account,Cost of Goods Sold,Náklady na prodej zboží
DocType: Purchase Invoice,Yearly,Ročne
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +228,Please enter Cost Center,"Prosím, zadajte nákladové stredisko"
DocType: Journal Entry Account,Sales Order,Predajné objednávky
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Selling Rate,Avg. Prodej Rate
DocType: Assessment Plan,Examiner Name,Meno Examiner
DocType: Purchase Invoice Item,Quantity and Rate,Množstvo a Sadzba
DocType: Delivery Note,% Installed,% Inštalovaných
apps/erpnext/erpnext/public/js/setup_wizard.js +376,Classrooms/ Laboratories etc where lectures can be scheduled.,"Učebne / etc laboratória, kde môžu byť naplánované prednášky."
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,"Prosím, zadajte najprv názov spoločnosti"
DocType: Purchase Invoice,Supplier Name,Názov dodávateľa
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Prečítajte si ERPNext Manuál
DocType: Account,Is Group,Is Group
DocType: Email Digest,Pending Purchase Orders,čaká objednávok
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Automaticky nastaviť sériových čísel na základe FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,"Skontrolujte, či dodávateľské faktúry Počet Jedinečnosť"
DocType: Vehicle Service,Oil Change,výmena oleja
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',"""Do Prípadu č ' nesmie byť menší ako ""Od Prípadu č '"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +115,Non Profit,Non Profit
DocType: Production Order,Not Started,Nezahájené
DocType: Lead,Channel Partner,Channel Partner
DocType: Account,Old Parent,Staré nadřazené
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Povinná oblasť - akademický rok
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Povinná oblasť - akademický rok
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,"Přizpůsobte si úvodní text, který jede jako součást tohoto e-mailu. Každá transakce je samostatný úvodní text."
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +157,Please set default payable account for the company {0},Nastavte predvolený splatný účet pre spoločnosť {0}
apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Globální nastavení pro všechny výrobní procesy.
DocType: Accounts Settings,Accounts Frozen Upto,Účty Frozen aľ
DocType: SMS Log,Sent On,Poslané na
apps/erpnext/erpnext/stock/doctype/item/item.py +635,Attribute {0} selected multiple times in Attributes Table,Atribút {0} vybraný niekoľkokrát v atribútoch tabuľke
DocType: HR Settings,Employee record is created using selected field. ,Zamestnanecký záznam sa vytvorí použitím vybraného poľa
DocType: Sales Order,Not Applicable,Nehodí se
apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Holiday master.
DocType: Request for Quotation Item,Required Date,Požadovaná data
DocType: Delivery Note,Billing Address,Fakturačná adresa
DocType: BOM,Costing,Rozpočet
DocType: Tax Rule,Billing County,Fakturačný okres
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Je-li zaškrtnuto, bude částka daně považovat za již zahrnuty v tisku Rate / Tisk Částka"
DocType: Request for Quotation,Message for Supplier,Správa pre dodávateľov
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Celkem Množství
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,ID e-mailu Guardian2
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,ID e-mailu Guardian2
DocType: Item,Show in Website (Variant),Zobraziť na webstránke (Variant)
DocType: Employee,Health Concerns,Zdravotní Obavy
DocType: Process Payroll,Select Payroll Period,Vyberte mzdové
DocType: Purchase Invoice,Unpaid,Nezaplacený
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Vyhradené pre predaj
DocType: Packing Slip,From Package No.,Od č balíčku
DocType: Item Attribute,To Range,K Rozsah
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Cenné papíry a vklady
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +44,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Metódu oceňovania nemožno zmeniť, pretože existujú transakcie proti niektorým položkám, ktoré nemajú vlastnú metódu oceňovania"
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Celkom listy pridelené je povinné
DocType: Job Opening,Description of a Job Opening,Popis jednoho volných pozic
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +111,Pending activities for today,Nevybavené aktivity pre dnešok
apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Účast rekord.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Plat komponentov pre mzdy časového rozvrhu.
DocType: Sales Order Item,Used for Production Plan,Používá se pro výrobní plán
DocType: Employee Loan,Total Payment,celkové platby
DocType: Manufacturing Settings,Time Between Operations (in mins),Doba medzi operáciou (v min)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +134,{0} {1} is cancelled so the action cannot be completed,"{0} {1} je zrušená, takže akciu nemožno dokončiť"
DocType: Customer,Buyer of Goods and Services.,Kupující zboží a služeb.
DocType: Journal Entry,Accounts Payable,Účty za úplatu
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +30,The selected BOMs are not for the same item,Vybrané kusovníky nie sú rovnaké položky
DocType: Supplier Scorecard Standing,Notify Other,Oznámiť iné
DocType: Pricing Rule,Valid Upto,Valid aľ
DocType: Training Event,Workshop,Dielňa
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Upozornenie na nákupné objednávky
apps/erpnext/erpnext/public/js/setup_wizard.js +257,List a few of your customers. They could be organizations or individuals.,"Vypíšte zopár svojich zákazníkov. Môžu to byť organizácie, ale aj jednotlivci."
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +21,Enough Parts to Build,Dosť Časti vybudovať
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Přímý příjmů
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Account, if grouped by Account","Nelze filtrovat na základě účtu, pokud seskupeny podle účtu"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +99,Administrative Officer,Správní ředitel
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +21,Please select Course,Vyberte možnosť Kurz
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +21,Please select Course,Vyberte možnosť Kurz
DocType: Timesheet Detail,Hrs,hod
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +342,Please select Company,"Prosím, vyberte spoločnosť"
DocType: Stock Entry Detail,Difference Account,Rozdíl účtu
DocType: Purchase Invoice,Supplier GSTIN,Dodávateľ GSTIN
apps/erpnext/erpnext/projects/doctype/task/task.py +46,Cannot close task as its dependant task {0} is not closed.,"Nedá zatvoriť úloha, ako jeho závislý úloha {0} nie je uzavretý."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +433,Please enter Warehouse for which Material Request will be raised,"Prosím, zadejte sklad, který bude materiál žádosti předložené"
DocType: Production Order,Additional Operating Cost,Další provozní náklady
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,Kosmetika
apps/erpnext/erpnext/stock/doctype/item/item.py +531,"To merge, following properties must be same for both items","Chcete-li sloučit, tyto vlastnosti musí být stejné pro obě položky"
DocType: Shipping Rule,Net Weight,Hmotnost
DocType: Employee,Emergency Phone,Nouzový telefon
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,kúpiť
,Serial No Warranty Expiry,Pořadové č záruční lhůty
DocType: Sales Invoice,Offline POS Name,Offline POS Name
apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Definujte stupeň pre prah 0%
apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Definujte stupeň pre prah 0%
DocType: Sales Order,To Deliver,Dodať
DocType: Purchase Invoice Item,Item,Položka
apps/erpnext/erpnext/accounts/page/pos/pos.js +2442,Serial no item cannot be a fraction,Sériovej žiadna položka nemôže byť zlomkom
DocType: Journal Entry,Difference (Dr - Cr),Rozdíl (Dr - Cr)
DocType: Account,Profit and Loss,Zisk a strata
apps/erpnext/erpnext/config/stock.py +325,Managing Subcontracting,Správa Subdodávky
DocType: Project,Project will be accessible on the website to these users,Projekt bude k dispozícii na webových stránkach k týmto užívateľom
apps/erpnext/erpnext/config/projects.py +23,Define Project type.,Definujte typ projektu.
DocType: Supplier Scorecard,Weighting Function,Funkcia váženia
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 +62,Account {0} does not belong to company: {1},Účet {0} nepatří k firmě: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Skratka už použitý pre inú spoločnosť
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
DocType: Sales Order Item,Gross Profit,Hrubý Zisk
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Prírastok nemôže byť 0
DocType: Production Planning Tool,Material Requirement,Materiál Požadavek
DocType: Company,Delete Company Transactions,Zmazať transakcie spoločnosti
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +347,Reference No and Reference Date is mandatory for Bank transaction,Referenčné číslo a referenčný dátum je povinný pre bankové transakcie
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Přidat / Upravit daní a poplatků
DocType: Purchase Invoice,Supplier Invoice No,Dodávateľská faktúra č
DocType: Territory,For reference,Pro srovnání
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Nemožno odstrániť Poradové číslo {0}, ktorý sa používa na sklade transakciách"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Cr),Uzavření (Cr)
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +105,Move Item,Posunúť položku
DocType: Serial No,Warranty Period (Days),Záruční doba (dny)
DocType: Installation Note Item,Installation Note Item,Poznámka k instalaci bod
DocType: Production Plan Item,Pending Qty,Čakajúci Množstvo
DocType: Budget,Ignore,Ignorovat
apps/erpnext/erpnext/accounts/party.py +361,{0} {1} is not active,{0} {1} nie je aktívny
apps/erpnext/erpnext/config/accounts.py +279,Setup cheque dimensions for printing,Skontrolujte nastavenie rozmery pre tlač
DocType: Salary Slip,Salary Slip Timesheet,Plat Slip časový rozvrh
apps/erpnext/erpnext/controllers/buying_controller.py +155,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,Partner predaja
apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Všetky hodnotiace karty dodávateľa.
DocType: Buying Settings,Purchase Receipt Required,Příjmka je vyžadována
apps/erpnext/erpnext/stock/doctype/item/item.py +130,Valuation Rate is mandatory if Opening Stock entered,"Ocenenie Rate je povinné, ak zadaná počiatočným stavom zásob"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +142,No records found in the Invoice table,Nalezené v tabulce faktury Žádné záznamy
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,Vyberte první společnost a Party Typ
apps/erpnext/erpnext/config/accounts.py +295,Financial / accounting year.,Finanční / Účetní rok.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,neuhradená Hodnoty
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Je nám líto, sériových čísel nelze sloučit"
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +63,Territory is Required in POS Profile,Územie je vyžadované v POS profile
DocType: Supplier,Prevent RFQs,Zabráňte RFQ
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +749,Make Sales Order,Vytvoriť prijatú objednávku
DocType: Project Task,Project Task,Úloha Project
,Lead Id,Id Obchodnej iniciatívy
DocType: C-Form Invoice Detail,Grand Total,Celkem
DocType: Training Event,Course,kurz
DocType: Timesheet,Payslip,výplatná páska
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,item košík
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Datum zahájení Fiskálního roku by nemělo být větší než datum ukončení
DocType: Issue,Resolution,Řešení
DocType: C-Form,IV,IV
apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Dodáva: {0}
DocType: Expense Claim,Payable Account,Splatnost účtu
DocType: Payment Entry,Type of Payment,typ platby
DocType: Sales Order,Billing and Delivery Status,Stav fakturácie a dodania
DocType: Job Applicant,Resume Attachment,Resume Attachment
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Verní zákazníci
DocType: Leave Control Panel,Allocate,Přidělit
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +804,Sales Return,Sales Return
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Poznámka: Celkový počet alokovaných listy {0} by nemala byť menšia ako ktoré už boli schválené listy {1} pre obdobie
,Total Stock Summary,Súhrnné zhrnutie zásob
DocType: Announcement,Posted By,Pridané
DocType: Item,Delivered by Supplier (Drop Ship),Dodáva Dodávateľom (Drop Ship)
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Databáze potenciálních zákazníků.
DocType: Authorization Rule,Customer or Item,Zákazník alebo položka
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Databáze zákazníků.
DocType: Quotation,Quotation To,Ponuka k
DocType: Lead,Middle Income,Středními příjmy
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Cr),Otvor (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py +799,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,"Východzí merná jednotka bodu {0} nemôže byť zmenená priamo, pretože ste už nejaké transakcie (y) s iným nerozpustených. Budete musieť vytvoriť novú položku použiť iný predvolený UOM."
apps/erpnext/erpnext/accounts/utils.py +349,Allocated amount can not be negative,Přidělená částka nemůže být záporná
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Nastavte spoločnosť
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Nastavte spoločnosť
DocType: Purchase Order Item,Billed Amt,Fakturovaná čiastka
DocType: Training Result Employee,Training Result Employee,vzdelávacie Výsledok
DocType: Warehouse,A logical Warehouse against which stock entries are made.,"Logická Warehouse na položky, které mohou být vyrobeny."
DocType: Repayment Schedule,Principal Amount,istina
DocType: Employee Loan Application,Total Payable Interest,Celková splatný úrok
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Predajná faktúry časový rozvrh
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Referenční číslo a referenční datum je nutné pro {0}
DocType: Process Payroll,Select Payment Account to make Bank Entry,"Vybrať Platobný účet, aby Bank Entry"
apps/erpnext/erpnext/utilities/activation.py +134,"Create Employee records to manage leaves, expense claims and payroll","Vytvoriť Zamestnanecké záznamy pre správu listy, vyhlásenia o výdavkoch a miezd"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +159,Proposal Writing,Návrh Psaní
DocType: Payment Entry Deduction,Payment Entry Deduction,Platba Vstup dedukcie
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Ďalšia predaja osoba {0} existuje s rovnakým id zamestnanca
DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Ak je zaškrtnuté, suroviny pre položky, ktoré sú subdodávateľsky budú zahrnuté v materiáli Žiadosti"
apps/erpnext/erpnext/config/accounts.py +80,Masters,Masters
DocType: Assessment Plan,Maximum Assessment Score,Maximálne skóre Assessment
apps/erpnext/erpnext/config/accounts.py +140,Update Bank Transaction Dates,Transakčné Data aktualizácie Bank
apps/erpnext/erpnext/config/projects.py +35,Time Tracking,Time Tracking
DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLIKÁT PRE TRANSPORTER
DocType: Fiscal Year Company,Fiscal Year Company,Spoločnosť pre fiškálny rok
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Training Event,Conference,konferencie
DocType: Timesheet,Billed,Fakturované
DocType: Batch,Batch Description,Popis Šarže
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Vytváranie študentských skupín
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Vytváranie študentských skupín
apps/erpnext/erpnext/accounts/utils.py +723,"Payment Gateway Account not created, please create one manually.","Platobná brána účet nevytvorili, prosím, vytvorte ručne."
DocType: Supplier Scorecard,Per Year,Za rok
DocType: Sales Invoice,Sales Taxes and Charges,Dane z predaja a poplatky
DocType: Employee,Organization Profile,Profil organizace
DocType: Student,Sibling Details,súrodenec Podrobnosti
DocType: Vehicle Service,Vehicle Service,servis vozidiel
apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Automaticky spúšťa žiadosť o spätné väzby na základe podmienok.
DocType: Employee,Reason for Resignation,Důvod rezignace
apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Šablona pro hodnocení výkonu.
DocType: Sales Invoice,Credit Note Issued,dobropisu vystaveného
DocType: Project Task,Weight,váha
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Faktura / Zápis do deníku Podrobnosti
apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} '{1}' nie je vo fiškálnom roku {2}
DocType: Buying Settings,Settings for Buying Module,Nastavenie pre modul Nákupy
apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Aktíva {0} nepatrí do spoločnosti {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,"Prosím, zadejte první doklad o zakoupení"
DocType: Buying Settings,Supplier Naming By,Pomenovanie dodávateľa podľa
DocType: Activity Type,Default Costing Rate,Predvolené kalkulácie Rate
DocType: Maintenance Schedule,Maintenance Schedule,Plán údržby
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Pak se pravidla pro tvorbu cen jsou odfiltrovány založeny na zákazníka, skupiny zákazníků, území, dodavatel, dodavatel typ, kampaň, obchodní partner atd"
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Čistá Zmena stavu zásob
apps/erpnext/erpnext/config/hr.py +157,Employee Loan Management,Zamestnanec úveru Vedenie
DocType: Employee,Passport Number,Číslo pasu
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Súvislosť s Guardian2
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +93,Manager,Manažér
DocType: Payment Entry,Payment From / To,Platba od / do
apps/erpnext/erpnext/selling/doctype/customer/customer.py +124,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nový úverový limit je nižšia ako aktuálna dlžnej čiastky za zákazníka. Úverový limit musí byť aspoň {0}
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""Založené na"" a ""Zoskupené podľa"", nemôžu byť rovnaké"
DocType: Sales Person,Sales Person Targets,Obchodník cíle
DocType: Installation Note,IN-,IN-
DocType: Production Order Operation,In minutes,V minútach
DocType: Issue,Resolution Date,Rozlišení Datum
DocType: Student Batch Name,Batch Name,Názov šarže
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +319,Timesheet created:,Harmonogramu vytvorenia:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +890,Please set default Cash or Bank account in Mode of Payment {0},Prosím nastavte výchozí v hotovosti nebo bankovním účtu v způsob platby {0}
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +20,Enroll,zapísať
DocType: GST Settings,GST Settings,Nastavenia GST
DocType: Selling Settings,Customer Naming By,Zákazník Pojmenování By
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Ukáže na študenta bol prítomný v Student mesačnú návštevnosť Správa
DocType: Depreciation Schedule,Depreciation Amount,odpisy Suma
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Převést do skupiny
DocType: Activity Cost,Activity Type,Druh činnosti
DocType: Request for Quotation,For individual supplier,Pre jednotlivé dodávateľa
DocType: BOM Operation,Base Hour Rate(Company Currency),Základňa hodinová sadzba (Company meny)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Dodává Částka
DocType: Supplier,Fixed Days,Pevné Dni
DocType: Quotation Item,Item Balance,Balance položka
DocType: Sales Invoice,Packing List,Zoznam balenia
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Nákupní Objednávky odeslané Dodavatelům.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,Zverejnenie
DocType: Activity Cost,Projects User,Projekty uživatele
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Spotřeba
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} nenájdené v tabuľke Podrobnosti Faktúry
DocType: Company,Round Off Cost Center,Zaokrúhliť nákladové stredisko
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +227,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Údržba Navštivte {0} musí být zrušena před zrušením této prodejní objednávky
DocType: Item,Material Transfer,Přesun materiálu
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Nepodarilo sa nájsť cestu pre
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +211,Opening (Dr),Opening (Dr)
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Časová značka zadání musí být po {0}
,GST Itemised Purchase Register,Registrovaný nákupný register spoločnosti GST
DocType: Employee Loan,Total Interest Payable,Celkové úroky splatné
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
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +285,Finish,Skončiť
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +395,Base,Základ
DocType: Timesheet,Total Billed Hours,Celkom Predpísané Hodiny
DocType: Journal Entry,Write Off Amount,Odepsat Částka
DocType: Leave Block List Allow,Allow User,Umožňuje uživateli
DocType: Journal Entry,Bill No,Bill No
DocType: Company,Gain/Loss Account on Asset Disposal,Zisk / straty na majetku likvidáciu
DocType: Vehicle Log,Service Details,Podrobnosti o službe
DocType: Vehicle Log,Service Details,Podrobnosti o službe
DocType: Purchase Invoice,Quarterly,Čtvrtletně
DocType: Selling Settings,Delivery Note Required,Dodací list povinný
DocType: Bank Guarantee,Bank Guarantee Number,Číslo bankovej záruky
DocType: Bank Guarantee,Bank Guarantee Number,Číslo bankovej záruky
DocType: Assessment Criteria,Assessment Criteria,Kritériá hodnotenia
DocType: BOM Item,Basic Rate (Company Currency),Basic Rate (Company měny)
DocType: Student Attendance,Student Attendance,študent Účasť
DocType: Sales Invoice Timesheet,Time Sheet,Časový rozvrh
DocType: Manufacturing Settings,Backflush Raw Materials Based On,So spätným suroviny na základe
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +84,Please enter item details,"Prosím, zadejte podrobnosti položky"
DocType: Interest,Interest,záujem
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Predpredaj
DocType: Purchase Receipt,Other Details,Ďalšie podrobnosti
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,Dodávateľ
DocType: Account,Accounts,Účty
DocType: Vehicle,Odometer Value (Last),Hodnota počítadla kilometrov (Last)
apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Šablóny kritérií kritérií pre dodávateľa.
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +78,Marketing,Marketing
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +284,Payment Entry is already created,Vstup Platba je už vytvorili
DocType: Request for Quotation,Get Suppliers,Získajte dodávateľov
DocType: Purchase Receipt Item Supplied,Current Stock,Current skladem
apps/erpnext/erpnext/controllers/accounts_controller.py +558,Row #{0}: Asset {1} does not linked to Item {2},Riadok # {0}: Asset {1} nie je spojená s item {2}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +377,Preview Salary Slip,Preview výplatnej páske
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Účet {0} bol zadaný viackrát
DocType: Account,Expenses Included In Valuation,Náklady ceně oceňování
DocType: Hub Settings,Seller City,Prodejce City
,Absent Student Report,Absent Študent Report
DocType: Email Digest,Next email will be sent on:,Další e-mail bude odeslán dne:
DocType: Offer Letter Term,Offer Letter Term,Ponuka Letter Term
DocType: Supplier Scorecard,Per Week,Za týždeň
apps/erpnext/erpnext/stock/doctype/item/item.py +614,Item has variants.,Položka má varianty.
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Položka {0} nebyl nalezen
DocType: Bin,Stock Value,Hodnota na zásobách
apps/erpnext/erpnext/accounts/doctype/account/account.py +26,Company {0} does not exist,Spoločnosť {0} neexistuje
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +82,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žstvo a sklad
DocType: Sales Invoice,Commission Rate (%),Výška provízie (%)
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +23,Please select Program,Vyberte program
DocType: Project,Estimated Cost,odhadované náklady
DocType: Purchase Order,Link to material requests,Odkaz na materiálnych požiadaviek
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Aerospace
DocType: Journal Entry,Credit Card Entry,Vstup Kreditní karta
apps/erpnext/erpnext/config/accounts.py +51,Company and Accounts,Spoločnosť a účty
apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Zboží od dodavatelů.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +58,In Value,v Hodnota
DocType: Lead,Campaign Name,Název kampaně
DocType: Selling Settings,Close Opportunity After Days,Close Opportunity po niekoľkých dňoch
,Reserved,Rezervováno
DocType: Purchase Order,Supply Raw Materials,Dodávok surovín
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 +94,{0} is not a stock Item,{0} nie je skladová položka
DocType: Mode of Payment Account,Default Account,Výchozí účet
DocType: Payment Entry,Received Amount (Company Currency),Prijaté Suma (Company mena)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +174,Lead must be set if Opportunity is made from Lead,Iniciatíva musí byť nastavená ak je Príležitosť vytváraná z Iniciatívy
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,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
apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Account with existing transaction cannot be converted to ledger,Účet s transakcemi nelze převést na hlavní účetní knihu
DocType: Delivery Note,Customer's Purchase Order No,Zákazníka Objednávka No
DocType: Budget,Budget Against,rozpočet Proti
DocType: Employee,Cell Number,Číslo buňky
apps/erpnext/erpnext/stock/reorder_item.py +177,Auto Material Requests Generated,Žiadosti Auto materiál vygenerovaný
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Ztracený
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,"Nelze zadat aktuální poukaz v ""Proti Zápis do deníku"" sloupci"
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Vyhradené pre výrobu
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,Energie
DocType: Opportunity,Opportunity From,Příležitost Z
apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Měsíční plat prohlášení.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +858,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Riadok {0}: {1} Sériové čísla vyžadované pre položku {2}. Poskytli ste {3}.
DocType: BOM,Website Specifications,Webových stránek Specifikace
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Kód položky&gt; Skupina položiek&gt; Značka
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Od {0} typu {1}
DocType: Warranty Claim,CI-,Ci
apps/erpnext/erpnext/controllers/buying_controller.py +289,Row {0}: Conversion Factor is mandatory,Row {0}: Konverzní faktor je povinné
DocType: Employee,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +326,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Viac Cena pravidlá existuje u rovnakých kritérií, prosím vyriešiť konflikt tým, že priradí prioritu. Cena Pravidlá: {0}"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +479,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: Item Attribute Value,Item Attribute Value,Položka Hodnota atributu
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Predajné kampane
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Make Timesheet,urobiť timesheet
DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### 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: Employee,Bank A/C No.,"Č, bank. účtu"
DocType: Bank Guarantee,Project,Projekt
DocType: Quality Inspection Reading,Reading 7,Čtení 7
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,čiastočne usporiadané
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/accounts/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Asset vyhodený cez položka denníka {0}
DocType: Employee Loan,Interest Income Account,Účet Úrokové výnosy
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Biotechnologie
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Náklady Office údržby
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Nastavenie e-mailového konta
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +114,Please enter Item first,"Prosím, najprv zadajte položku"
DocType: Account,Liability,Odpovědnost
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +186,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sankcionovaná Čiastka nemôže byť väčšia ako reklamácia Suma v riadku {0}.
DocType: Company,Default Cost of Goods Sold Account,Východiskové Náklady na predaný tovar účte
apps/erpnext/erpnext/stock/get_item_details.py +310,Price List not selected,Nie je zvolený cenník
DocType: Employee,Family Background,Rodinné poměry
DocType: Request for Quotation Supplier,Send Email,Odoslať email
apps/erpnext/erpnext/stock/doctype/item/item.py +204,Warning: Invalid Attachment {0},Varovanie: Neplatná Príloha {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +755,No Permission,Nemáte oprávnenie
DocType: Company,Default Bank Account,Prednastavený Bankový účet
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +50,"To filter based on Party, select Party Type first","Ak chcete filtrovať na základe Party, vyberte typ Party prvý"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"""Aktualizovať Sklad ' nie je možné skontrolovať, pretože položky nie sú dodané cez {0}"
DocType: Vehicle,Acquisition Date,akvizície Dátum
apps/erpnext/erpnext/public/js/setup_wizard.js +310,Nos,Balenie
DocType: Item,Items with higher weightage will be shown higher,Položky s vyšším weightage budú zobrazené vyššie
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Detail bankového odsúhlasenia
apps/erpnext/erpnext/controllers/accounts_controller.py +562,Row #{0}: Asset {1} must be submitted,Riadok # {0}: {1} Asset musia byť predložené
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Nenájdený žiadny zamestnanec
DocType: Supplier Quotation,Stopped,Zastavené
DocType: Item,If subcontracted to a vendor,Ak sa subdodávky na dodávateľa
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +111,Student Group is already updated.,Skupina študentov je už aktualizovaná.
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +111,Student Group is already updated.,Skupina študentov je už aktualizovaná.
DocType: SMS Center,All Customer Contact,Všetky Kontakty Zákazníka
apps/erpnext/erpnext/config/stock.py +153,Upload stock balance via csv.,Nahrát nutnosti rovnováhy prostřednictvím CSV.
DocType: Warehouse,Tree Details,Tree Podrobnosti
DocType: Training Event,Event Status,event Status
,Support Analytics,Podpora Analytics
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +346,"If you have any questions, please get back to us.","Ak máte akékoľvek otázky, obráťte sa na nás."
DocType: Item,Website Warehouse,Sklad pro web
DocType: Payment Reconciliation,Minimum Invoice Amount,Minimálna suma faktúry
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: náklady Center {2} nepatrí do spoločnosti {3}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Účet {2} nemôže byť skupina
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Položka Row {idx}: {typ_dokumentu} {} DOCNAME neexistuje v predchádzajúcom &#39;{typ_dokumentu}&#39; tabuľka
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +288,Timesheet {0} is already completed or cancelled,Harmonogramu {0} je už dokončená alebo zrušená
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,žiadne úlohy
DocType: Purchase 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"
DocType: Asset,Opening Accumulated Depreciation,otvorenie Oprávky
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Skóre musí být menší než nebo rovna 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Program Tool zápis
apps/erpnext/erpnext/config/accounts.py +332,C-Form records,C-Form záznamy
apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Zákazník a Dodávateľ
DocType: Email Digest,Email Digest Settings,Nastavení e-mailu Digest
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +348,Thank you for your business!,Ďakujeme vám za vašu firmu!
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Podpora dotazy ze strany zákazníků.
,Production Order Stock Report,Zákazková výroba Reklamná Report
DocType: HR Settings,Retirement Age,dôchodkový vek
DocType: Bin,Moving Average Rate,Klouzavý průměr
DocType: Production Planning Tool,Select Items,Vyberte položky
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} proti účtu {1} z dňa {2}
DocType: Program Enrollment,Vehicle/Bus Number,Číslo vozidla / autobusu
apps/erpnext/erpnext/schools/doctype/course/course.js +17,Course Schedule,rozvrh
DocType: Request for Quotation Supplier,Quote Status,Citácia Stav
DocType: Maintenance Visit,Completion Status,Dokončení Status
DocType: HR Settings,Enter retirement age in years,Zadajte vek odchodu do dôchodku v rokoch
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +263,Target Warehouse,Target Warehouse
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +102,Please select a warehouse,Vyberte si sklad
DocType: Cheque Print Template,Starting location from left edge,Počnúc umiestnenie od ľavého okraja
DocType: Item,Allow over delivery or receipt upto this percent,Nechajte cez dodávku alebo príjem aľ tohto percenta
DocType: Stock Entry,STE-,ste-
DocType: Upload Attendance,Import Attendance,Importovat Docházku
apps/erpnext/erpnext/public/js/pos/pos.html +115,All Item Groups,Všechny skupiny položek
DocType: Process Payroll,Activity Log,Aktivita Log
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Net Profit / Loss,Čistý zisk / strata
apps/erpnext/erpnext/config/setup.py +89,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/buying/utils.py +80,{0} {1} status is {2},{0} {1} stav je {2}
DocType: Employee,Provide Email Address registered in company,Poskytnúť e-mailovú adresu registrovanú vo firme
DocType: Shopping Cart Settings,Enable Checkout,aktivovať Checkout
apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Objednávka na platobné
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Předpokládané množství
DocType: Sales Invoice,Payment Due Date,Splatné dňa
apps/erpnext/erpnext/stock/doctype/item/item.js +349,Item Variant {0} already exists with same attributes,Variant Položky {0} už existuje s rovnakými vlastnosťami
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening',"""Otváranie"""
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,otvorená robiť
DocType: Notification Control,Delivery Note Message,Delivery Note Message
DocType: Expense Claim,Expenses,Výdaje
DocType: Item Variant Attribute,Item Variant Attribute,Vlastnosť Variantu Položky
,Purchase Receipt Trends,Doklad o koupi Trendy
DocType: Process Payroll,Bimonthly,dvojmesačne
DocType: Vehicle Service,Brake Pad,Brzdová doštička
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Research & Development,Výzkum a vývoj
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Částka k Fakturaci
DocType: Company,Registration Details,Registrace Podrobnosti
DocType: Timesheet,Total Billed Amount,Celková suma Fakturovaný
DocType: Item Reorder,Re-Order Qty,Re-Order Množství
DocType: Leave Block List Date,Leave Block List Date,Nechte Block List Datum
DocType: Pricing Rule,Price or Discount,Cena alebo zľava
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +95,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Surovina nemôže byť rovnaká ako hlavná položka
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,"Celkom Použiteľné Poplatky v doklade o kúpe tovaru, ktorý tabuľky musí byť rovnaká ako celkom daní a poplatkov"
DocType: Sales Team,Incentives,Pobídky
DocType: SMS Log,Requested Numbers,Požadované Čísla
DocType: Production Planning Tool,Only Obtain Raw Materials,Získať iba suroviny
apps/erpnext/erpnext/config/hr.py +142,Performance appraisal.,Hodnocení výkonu.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +96,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Povolenie &quot;použitia na nákupného košíka&quot;, ako je povolené Nákupný košík a tam by mala byť aspoň jedna daňové pravidlá pre Košík"
apps/erpnext/erpnext/controllers/accounts_controller.py +360,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Platba Vstup {0} je prepojený na objednávku {1}, skontrolujte, či by mal byť ťahaný za pokrok v tejto faktúre."
DocType: Sales Invoice Item,Stock Details,Detaily zásob
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Hodnota projektu
apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Mieste predaja
DocType: Vehicle Log,Odometer Reading,stav tachometra
apps/erpnext/erpnext/accounts/doctype/account/account.py +119,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Zůstatek na účtu již v Credit, není dovoleno stanovit ""Balance musí být"" jako ""debet"""
DocType: Account,Balance must be,Zostatok musí byť
DocType: Hub Settings,Publish Pricing,Zverejniť ceny
DocType: Notification Control,Expense Claim Rejected Message,Zpráva o zamítnutí úhrady výdajů
,Available Qty,Množství k dispozici
DocType: Purchase Taxes and Charges,On Previous Row Total,Na předchozí řady Celkem
DocType: Purchase Invoice Item,Rejected Qty,zamietnutá Množstvo
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/public/js/setup_wizard.js +92,The name of your company for which you are setting up this system.,"Názov spoločnosti, pre ktorú nastavujete tento systém"
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ů
DocType: Examination Result,Examination Result,vyšetrenie Výsledok
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +811,Purchase Receipt,Příjemka
,Received Items To Be Billed,"Přijaté položek, které mají být účtovány"
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +173,Submitted Salary Slips,Predložené výplatných páskach
apps/erpnext/erpnext/config/accounts.py +305,Currency exchange rate master.,Devizový kurz master.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +196,Reference Doctype must be one of {0},Referenčná DOCTYPE musí byť jedným z {0}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +302,Unable to find Time Slot in the next {0} days for Operation {1},Nemožno nájsť časový úsek v najbližších {0} dní na prevádzku {1}
DocType: Production Order,Plan material for sub-assemblies,Plán materiál pro podsestavy
apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Obchodní partneri a teritória
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +558,BOM {0} must be active,BOM {0} musí být aktivní
DocType: Journal Entry,Depreciation Entry,odpisy Entry
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Najprv vyberte typ dokumentu
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Zrušit Materiál Návštěvy {0} před zrušením tohoto návštěv údržby
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},Pořadové číslo {0} nepatří k bodu {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Požadované množství
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +123,Warehouses with existing transaction can not be converted to ledger.,Sklady s existujúcimi transakcie nemožno previesť na knihy.
DocType: Bank Reconciliation,Total Amount,Celková částka
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +32,Internet Publishing,Internet Publishing
DocType: Production Planning Tool,Production Orders,Výrobní Objednávky
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +62,Balance Value,Hodnota zostatku
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Predajný cenník
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +69,Publish to sync items,Publikování synchronizovat položky
DocType: Bank Reconciliation,Account Currency,Mena účtu
apps/erpnext/erpnext/accounts/general_ledger.py +142,Please mention Round Off Account in Company,"Prosím, uveďte zaokrúhliť účet v spoločnosti"
DocType: Purchase Receipt,Range,Rozsah
DocType: Supplier,Default Payable Accounts,Výchozí úplatu účty
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Zamestnanec {0} nie je aktívny alebo neexistuje
DocType: Fee Structure,Components,komponenty
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +251,Please enter Asset Category in Item {0},"Prosím, zadajte Kategória majetku v položke {0}"
DocType: Quality Inspection Reading,Reading 6,Čtení 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +913,Cannot {0} {1} {2} without any negative outstanding invoice,Nemožno {0} {1} {2} bez negatívnych vynikajúce faktúra
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Záloha přijaté faktury
DocType: Hub Settings,Sync Now,Sync teď
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit záznam nemůže být spojována s {1}
apps/erpnext/erpnext/config/accounts.py +248,Define budget for a financial year.,Definovať rozpočet pre finančný rok.
DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,"Výchozí účet Bank / Cash budou automaticky aktualizovány v POS faktury, pokud je zvolen tento režim."
DocType: Lead,LEAD-,INI-
DocType: Employee,Permanent Address Is,Trvalé bydliště je
DocType: Production Order Operation,Operation completed for how many finished goods?,Provoz dokončeno kolika hotových výrobků?
apps/erpnext/erpnext/public/js/setup_wizard.js +42,The Brand,Značka
DocType: Employee,Exit Interview Details,Exit Rozhovor Podrobnosti
DocType: Item,Is Purchase Item,je Nákupní Položka
DocType: Asset,Purchase Invoice,Prijatá faktúra
DocType: Stock Ledger Entry,Voucher Detail No,Voucher Detail No
apps/erpnext/erpnext/accounts/page/pos/pos.js +745,New Sales Invoice,Nová predajná faktúra
DocType: Stock Entry,Total Outgoing Value,Celková hodnota Odchozí
apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Dátum začatia a dátumom ukončenia by malo byť v rámci rovnakého fiškálny rok
DocType: Lead,Request for Information,Žádost o informace
,LeaderBoard,Nástenka lídrov
apps/erpnext/erpnext/accounts/page/pos/pos.js +758,Sync Offline Invoices,Sync Offline Faktúry
DocType: Payment Request,Paid,Zaplatené
DocType: Program Fee,Program Fee,program Fee
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.","Nahradiť konkrétny kusovník vo všetkých ostatných kusovníkoch, kde sa používa. Bude nahradiť starý odkaz BOM, aktualizovať cenu a obnoviť tabuľku &quot;BOM Explosion Item&quot; podľa nového kusovníka. Aktualizuje tiež poslednú cenu vo všetkých kusovníkoch."
DocType: Salary Slip,Total in words,Celkem slovy
DocType: Material Request Item,Lead Time Date,Čas a Dátum Obchodnej iniciatívy
DocType: Guardian,Guardian Name,Meno Guardian
DocType: Cheque Print Template,Has Print Format,Má formát tlače
DocType: Employee Loan,Sanctioned,Sankcionované
apps/erpnext/erpnext/accounts/page/pos/pos.js +73, is mandatory. Maybe Currency Exchange record is not created for ,"je povinné. Možno, Zmenáreň záznam nie je vytvorená pre"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +112,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Zadejte Pořadové číslo k bodu {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +622,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pre &quot;produktom Bundle predmety, sklad, sériové číslo a dávkové No bude považovaná zo&quot; Balenie zoznam &#39;tabuľky. Ak Warehouse a Batch No sú rovnaké pre všetky balenia položky pre akúkoľvek &quot;Výrobok balík&quot; položky, tieto hodnoty môžu byť zapísané do hlavnej tabuľky položky, budú hodnoty skopírované do &quot;Balenie zoznam&quot; tabuľku."
DocType: Job Opening,Publish on website,Publikovať na webových stránkach
apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Zásilky zákazníkům.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +624,Supplier Invoice Date cannot be greater than Posting Date,Dodávateľ Dátum faktúry nemôže byť väčšia ako Dátum zverejnenia
DocType: Purchase Invoice Item,Purchase Order Item,Položka nákupnej objednávky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Nepřímé příjmy
DocType: Student Attendance Tool,Student Attendance Tool,Študent Účasť Tool
DocType: Cheque Print Template,Date Settings,dátum Nastavenie
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Odchylka
,Company Name,Názov spoločnosti
DocType: SMS Center,Total Message(s),Celkem zpráv (y)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +863,Select Item for Transfer,Vybrať položku pre prevod
DocType: Purchase Invoice,Additional Discount Percentage,Ďalšie zľavy Percento
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Zobraziť zoznam všetkých videí nápovedy
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Vyberte účet šéf banky, kde byla uložena kontrola."
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Povolit uživateli upravovat Ceník Cena při transakcích
DocType: Pricing Rule,Max Qty,Max Množství
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
						Please enter a valid Invoice","Riadok {0}: faktúra {1} je neplatná, to by mohlo byť zrušené / neexistuje. \ Zadajte platnú faktúru"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Row {0}: Platba na prodejní / nákupní objednávce by měly být vždy označeny jako předem
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +16,Chemical,Chemický
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Východisková banka / Peňažný účet budú automaticky aktualizované v plat položka denníku ak je zvolený tento režim.
DocType: BOM,Raw Material Cost(Company Currency),Raw Material Cost (Company mena)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +731,All items have already been transferred for this Production Order.,Všechny položky již byly převedeny na výrobu tohoto řádu.
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Riadok # {0}: Sadzba nesmie byť vyššia ako sadzba použitá v {1} {2}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Riadok # {0}: Sadzba nesmie byť vyššia ako sadzba použitá v {1} {2}
apps/erpnext/erpnext/public/js/setup_wizard.js +311,Meter,meter
DocType: Workstation,Electricity Cost,Cena elektřiny
DocType: HR Settings,Don't send Employee Birthday Reminders,Neposílejte zaměstnance připomenutí narozenin
DocType: Item,Inspection Criteria,Inšpekčné kritéria
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Prevedené
DocType: BOM Website Item,BOM Website Item,BOM Website Item
apps/erpnext/erpnext/public/js/setup_wizard.js +43,Upload your letter head and logo. (you can edit them later).,Nahrajte svoju hlavičku a logo pre dokumenty. (Môžete ich upravovať neskôr.)
DocType: Timesheet Detail,Bill,Účtenka
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Vedľa Odpisy Dátum sa zadáva ako uplynulom dni
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +177,White,Biela
DocType: SMS Center,All Lead (Open),Všetky Iniciatívy (Otvorené)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +231,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Riadok {0}: Množstvo nie je k dispozícii pre {4} v sklade {1} pri účtovaní čas zápisu ({2} {3})
DocType: Purchase Invoice,Get Advances Paid,Získejte zaplacené zálohy
DocType: Item,Automatically Create New Batch,Automaticky vytvoriť novú dávku
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Make ,Urobiť
DocType: Student Admission,Admission Start Date,Vstupné Dátum začatia
DocType: Journal Entry,Total Amount in Words,Celková částka slovy
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,"Došlo k chybě. Jedním z důvodů by mohlo být pravděpodobné, že jste uložili formulář. Obraťte se prosím na support@erpnext.com Pokud problém přetrvává."
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Môj košík
apps/erpnext/erpnext/controllers/selling_controller.py +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 +36,Opening Qty,Otevření POČET
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +466,Please enter Account for Change Amount,"Prosím, zadajte účet pre zmenu Suma"
DocType: Student Batch Name,Student Batch Name,Študent Batch Name
DocType: Holiday List,Holiday List Name,Názov zoznamu sviatkov
DocType: Repayment Schedule,Balance Loan Amount,Bilancia Výška úveru
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.js +13,Schedule Course,rozvrh
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +197,Stock Options,Možnosti zásob
DocType: Journal Entry Account,Expense Claim,Hrazení nákladů
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +245,Do you really want to restore this scrapped asset?,Naozaj chcete obnoviť tento vyradený aktívum?
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +349,Qty for {0},Množství pro {0}
DocType: Leave Application,Leave Application,Aplikácia na priepustky
apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Nástroj na pridelenie voľna
DocType: Leave Block List,Leave Block List Dates,Nechte Block List termíny
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: Company,Default Terms,Východiskové podmienky
DocType: Supplier Scorecard Period,Criteria,kritériá
DocType: Packing Slip Item,Packing Slip Item,Balení Slip Item
DocType: Purchase Invoice,Cash/Bank Account,Hotovostný / Bankový účet
apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Zadajte {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Removed items with no change in quantity or value.,Odstránené položky bez zmeny množstva alebo hodnoty.
DocType: Delivery Note,Delivery To,Doručení do
apps/erpnext/erpnext/stock/doctype/item/item.py +632,Attribute table is mandatory,Atribút tabuľka je povinné
DocType: Production Planning Tool,Get Sales Orders,Získat Prodejní objednávky
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} nemôže byť záporné
apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +11,Discount,Sleva
DocType: Asset,Total Number of Depreciations,Celkový počet Odpisy
DocType: Sales Invoice Item,Rate With Margin,Sadzba s maržou
DocType: Sales Invoice Item,Rate With Margin,Sadzba s maržou
DocType: Workstation,Wages,Mzdy
DocType: Task,Urgent,Naléhavý
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +157,Please specify a valid Row ID for row {0} in table {1},Zadajte platný riadok ID riadku tabuľky {0} {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Nepodarilo sa nájsť premennú:
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Prejdite na plochu a začnite používať ERPNext
DocType: Item,Manufacturer,Výrobca
DocType: Landed Cost Item,Purchase Receipt Item,Položka příjemky
DocType: Purchase Receipt,PREC-RET-,PREC-RET-
DocType: POS Profile,Sales Invoice Payment,Predajná faktúry Platba
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 +73,Selling Amount,Predajná čiastka
DocType: Repayment Schedule,Interest Amount,záujem Suma
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +109,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Jste Expense schvalujícím pro tento záznam. Prosím aktualizujte ""stavu"" a Uložit"
DocType: Serial No,Creation Document No,Tvorba dokument č
DocType: Issue,Issue,Problém
DocType: Asset,Scrapped,zošrotovaný
apps/erpnext/erpnext/config/stock.py +195,"Attributes for Item Variants. e.g Size, Color etc.","Atributy pro položky varianty. například velikost, barva atd."
DocType: Purchase Invoice,Returns,výnos
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP Warehouse
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},Pořadové číslo {0} je na základě smlouvy o údržbě aľ {1}
apps/erpnext/erpnext/config/hr.py +35,Recruitment,nábor
DocType: Lead,Organization Name,Názov organizácie
DocType: Tax Rule,Shipping State,Prepravné State
,Projected Quantity as Source,Množstvo projekciou as Zdroj
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,"Položka musí být přidány pomocí ""získat předměty z kupní příjmy"" tlačítkem"
DocType: Employee,A-,A-
DocType: Production Planning Tool,Include non-stock items,Zahŕňajú non-skladových položiek
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Predajné náklady
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Štandardný nákup
DocType: GL Entry,Against,Proti
DocType: Item,Default Selling Cost Center,Výchozí Center Prodejní cena
DocType: Sales Partner,Implementation Partner,Implementačního partnera
apps/erpnext/erpnext/accounts/page/pos/pos.js +1562,ZIP Code,PSČ
apps/erpnext/erpnext/controllers/selling_controller.py +265,Sales Order {0} is {1},Predajné objednávky {0} {1}
DocType: Opportunity,Contact Info,Kontaktní informace
apps/erpnext/erpnext/config/stock.py +310,Making Stock Entries,Tvorba prírastkov zásob
DocType: Packing Slip,Net Weight UOM,Čistá hmotnosť MJ
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +20,{0} Results,{0} výsledkov
DocType: Item,Default Supplier,Výchozí Dodavatel
DocType: Manufacturing Settings,Over Production Allowance Percentage,Nad výrobou Percento príspevkoch
DocType: Employee Loan,Repayment Schedule,splátkový kalendár
DocType: Shipping Rule Condition,Shipping Rule Condition,Přepravní Pravidlo Podmínka
DocType: Holiday List,Get Weekly Off Dates,Získejte týdenní Off termíny
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Datum ukončení nesmí být menší než data zahájení
DocType: Sales Person,Select company name first.,"Prosím, vyberte najprv názov spoločnosti"
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Ponuky od Dodávateľov.
apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Nahraďte kusovník a aktualizujte najnovšiu cenu vo všetkých kusovníkoch
apps/erpnext/erpnext/controllers/selling_controller.py +22,To {0} | {1} {2},Chcete-li {0} | {1} {2}
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Průměrný věk
DocType: School Settings,Attendance Freeze Date,Účasť
DocType: School Settings,Attendance Freeze Date,Účasť
apps/erpnext/erpnext/public/js/setup_wizard.js +277,List a few of your suppliers. They could be organizations or individuals.,"Napíšte niekoľkých svojich dodávateľov. Môžu to byť organizácie, ale aj jednotlivci."
apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Zobraziť všetky produkty
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimálny vek vedenia (dni)
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Minimálny vek vedenia (dni)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +61,All BOMs,všetky kusovníky
DocType: Company,Default Currency,Predvolená mena
DocType: Expense Claim,From Employee,Od Zaměstnance
apps/erpnext/erpnext/controllers/accounts_controller.py +420,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
DocType: Program Enrollment,Transportation,Doprava
apps/erpnext/erpnext/controllers/item_variant.py +92,Invalid Attribute,neplatný Atribút
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +225,{0} {1} must be submitted,{0} {1} musí být odeslaný
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +146,Quantity must be less than or equal to {0},Množstvo musí byť menší ako alebo rovný {0}
DocType: SMS Center,Total Characters,Celkový počet znaků
apps/erpnext/erpnext/controllers/buying_controller.py +159,Please select BOM in BOM field for Item {0},Vyberte kusovník Bom oblasti k bodu {0}
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Faktura Detail
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Platba Odsouhlasení faktury
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,Příspěvek%
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +211,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Podľa nákupných nastavení, ak je objednávka požadovaná == &#39;ÁNO&#39;, potom pre vytvorenie nákupnej faktúry musí používateľ najprv vytvoriť nákupnú objednávku pre položku {0}"
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Registrace firmy čísla pro váš odkaz. Daňové čísla atd
DocType: Sales Partner,Distributor,Distributor
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Nákupní košík Shipping Rule
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +233,Production Order {0} must be cancelled before cancelling this Sales Order,Výrobní zakázka {0} musí být zrušena před zrušením této prodejní objednávky
apps/erpnext/erpnext/public/js/controllers/transaction.js +67,Please set 'Apply Additional Discount On',Prosím nastavte na &quot;Použiť dodatočnú zľavu On&quot;
,Ordered Items To Be Billed,Objednané zboží fakturovaných
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,"Z rozsahu, musí byť nižšia ako na Range"
DocType: Global Defaults,Global Defaults,Globální Výchozí
apps/erpnext/erpnext/projects/doctype/project/project.py +210,Project Collaboration Invitation,Projekt spolupráce Pozvánka
DocType: Salary Slip,Deductions,Odpočty
DocType: Leave Allocation,LAL/,LAL /
apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Začiatočný rok
apps/erpnext/erpnext/regional/india/utils.py +24,First 2 digits of GSTIN should match with State number {0},Prvé dve číslice GSTIN by sa mali zhodovať so stavovým číslom {0}
DocType: Purchase Invoice,Start date of current invoice's period,Datum období současného faktury je Začátek
DocType: Salary Slip,Leave Without Pay,Nechat bez nároku na mzdu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,Capacity Planning Error,Plánovanie kapacít Chyba
,Trial Balance for Party,Trial váhy pre stranu
DocType: Lead,Consultant,Konzultant
DocType: Salary Slip,Earnings,Príjmy
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +391,Finished Item {0} must be entered for Manufacture type entry,Dokončené Položka {0} musí byť zadaný pre vstup typu Výroba
apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Otvorenie účtovníctva Balance
,GST Sales Register,Obchodný register spoločnosti GST
DocType: Sales Invoice Advance,Sales Invoice Advance,Prodejní faktury Advance
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +548,Nothing to request,Nic požadovat
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Ďalšie rekord Rozpočet &#39;{0}&#39; už existuje proti {1} &#39;{2}&#39; za fiškálny rok {3}
apps/erpnext/erpnext/projects/doctype/task/task.py +40,'Actual Start Date' can not be greater than 'Actual End Date',"""Aktuálny datum začiatku"" nemôže byť väčší ako ""Aktuálny dátum ukončenia"""
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Management,Manažment
DocType: Cheque Print Template,Payer Settings,nastavenie platcu
DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","To bude připojen na položku zákoníku varianty. Například, pokud vaše zkratka je ""SM"", a položka je kód ""T-SHIRT"", položka kód varianty bude ""T-SHIRT-SM"""
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,"Čistá Pay (slovy) budou viditelné, jakmile uložíte výplatní pásce."
DocType: Purchase Invoice,Is Return,Je Return
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +79,Caution,pozor
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +787,Return / Debit Note,Return / ťarchopis
DocType: Price List Country,Price List Country,Cenník Krajina
DocType: Item,UOMs,Merné Jednotky
apps/erpnext/erpnext/stock/utils.py +205,{0} valid serial nos for Item {1},{0} platné sériové čísla pre položky {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Kód položky nemůže být změněn pro Serial No.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +26,POS Profile {0} already created for user: {1} and company {2},POS Profile {0} už vytvorili pre užívateľov: {1} a spoločnosť {2}
DocType: Sales Invoice Item,UOM Conversion Factor,Faktor konverzie MJ
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +23,Please enter Item Code to get Batch Number,"Prosím, zadajte kód položky sa dostať číslo šarže"
DocType: Stock Settings,Default Item Group,Výchozí bod Group
DocType: Employee Loan,Partially Disbursed,čiastočne Vyplatené
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Databáze dodavatelů.
DocType: Account,Balance Sheet,Rozvaha
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +701,Cost Center For Item with Item Code ',"Nákladové středisko u položky s Kód položky """
DocType: Quotation,Valid Till,Platný do
apps/erpnext/erpnext/accounts/page/pos/pos.js +2403,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Režim platba nie je nakonfigurovaný. Prosím skontrolujte, či je účet bol nastavený na režim platieb alebo na POS Profilu."
apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Rovnakú položku nemožno zadávať viackrát.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Further accounts can be made under Groups, but entries can be made against non-Groups","Ďalšie účty môžu byť vyrobené v rámci skupiny, ale údaje je možné proti non-skupín"
DocType: Lead,Lead,Obchodná iniciatíva
DocType: Email Digest,Payables,Závazky
DocType: Course,Course Intro,samozrejme Intro
apps/erpnext/erpnext/stock/doctype/batch/batch.js +85,Stock Entry {0} created,Sklad Vstup {0} vytvoril
apps/erpnext/erpnext/controllers/buying_controller.py +295,Row #{0}: Rejected Qty can not be entered in Purchase Return,Riadok # {0}: zamietnutie Množstvo nemôže byť zapísaný do kúpnej Návrat
,Purchase Order Items To Be Billed,Položky vydané objednávky k fakturaci
DocType: Purchase Invoice Item,Net Rate,Čistá miera
DocType: Purchase Invoice Item,Purchase Invoice Item,Položka přijaté faktury
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Sériové Ledger Přihlášky a GL položky jsou zveřejňována pro vybrané Nákupní Příjmy
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Položka 1
DocType: Holiday,Holiday,Dovolená
DocType: Support Settings,Close Issue After Days,Close Issue po niekoľkých dňoch
DocType: Leave Control Panel,Leave blank if considered for all branches,"Ponechte prázdné, pokud se to považuje za všechny obory"
DocType: Bank Guarantee,Validity in Days,Platnosť v dňoch
DocType: Bank Guarantee,Validity in Days,Platnosť v dňoch
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-forma sa nevzťahuje na faktúre: {0}
DocType: Payment Reconciliation,Unreconciled Payment Details,Smířit platbě
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Počet objednávok
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Počet objednávok
DocType: Global Defaults,Current Fiscal Year,Aktuálny fiškálny rok
DocType: Purchase Order,Group same items,Skupina rovnaké položky
DocType: Global Defaults,Disable Rounded Total,Zakázat Zaoblený Celkem
DocType: Employee Loan Application,Repayment Info,splácanie Info
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,"""Položky"" nemôžu býť prázdne"
apps/erpnext/erpnext/utilities/transaction_base.py +81,Duplicate row {0} with same {1},Duplicitný riadok {0} s rovnakým {1}
,Trial Balance,Trial Balance
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +449,Fiscal Year {0} not found,Fiškálny rok {0} nebol nájdený
apps/erpnext/erpnext/config/hr.py +296,Setting up Employees,Nastavenia pre modul Zamestnanci
DocType: Sales Order,SO-,PO-
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,"Prosím, vyberte první prefix"
DocType: Employee,O-,O-
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +158,Research,Výzkum
DocType: Maintenance Visit Purpose,Work Done,Odvedenou práci
apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,Uveďte aspoň jeden atribút v tabuľke atribúty
DocType: Announcement,All Students,všetci študenti
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Item {0} musí byť non-skladová položka
apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,View Ledger
DocType: Grading Scale,Intervals,intervaly
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Najstarší
apps/erpnext/erpnext/stock/doctype/item/item.py +505,"An Item Group exists with same name, please change the item name or rename the item group","Položka Group existuje se stejným názvem, prosím, změnit název položky nebo přejmenovat skupinu položek"
apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Študent Mobile No.
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +487,Rest Of The World,Zbytek světa
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,Položka {0} nemůže mít dávku
,Budget Variance Report,Rozpočet Odchylka Report
DocType: Salary Slip,Gross Pay,Hrubé mzdy
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Activity Type is mandatory.,Riadok {0}: typ činnosti je povinná.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Dividends Paid,Dividendy platené
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Účtovné Ledger
DocType: Stock Reconciliation,Difference Amount,Rozdiel Suma
DocType: Purchase Invoice,Reverse Charge,Spätné nabíjanie
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Nerozdelený zisk
DocType: Vehicle Log,Service Detail,servis Detail
DocType: BOM,Item Description,Položka Popis
DocType: Student Sibling,Student Sibling,študent Súrodenec
DocType: Purchase Invoice,Is Recurring,Je opakujúce sa
DocType: Purchase Invoice,Supplied Items,Dodávané položky
DocType: Student,STUD.,STUD.
DocType: Production Order,Qty To Manufacture,Množství K výrobě
DocType: Email Digest,New Income,new príjmov
DocType: School Settings,School Settings,Školské nastavenia
DocType: School Settings,School Settings,Školské nastavenia
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Udržovat stejnou sazbu po celou kupní cyklu
DocType: Opportunity Item,Opportunity Item,Položka Příležitosti
,Student and Guardian Contact Details,Študent a Guardian Kontaktné údaje
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +51,Row {0}: For supplier {0} Email Address is required to send email,Riadok {0}: Pre dodávateľov je potrebná {0} E-mailová adresa pre odoslanie e-mailu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,Dočasné Otvorenie
,Employee Leave Balance,Zostatok voľna pre zamestnanca
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Zostatok na účte {0} musí byť vždy {1}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +178,Valuation Rate required for Item in row {0},Ocenenie Miera potrebná pre položku v riadku {0}
DocType: Supplier Scorecard,Scorecard Actions,Akcie Scorecard
apps/erpnext/erpnext/public/js/setup_wizard.js +331,Example: Masters in Computer Science,Príklad: Masters v informatike
DocType: Purchase Invoice,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/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Ak chcete získať to najlepšie z ERPNext, odporúčame vám nejaký čas venovať týmto videám."
apps/erpnext/erpnext/accounts/page/pos/pos.js +74, to ,k
DocType: Supplier Quotation Item,Lead Time in days,Vek Obchodnej iniciatívy v dňoch
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Splatné účty Shrnutí
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +337,Payment of salary from {0} to {1},Výplata platu od {0} do {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Není povoleno upravovat zmrazený účet {0}
DocType: Journal Entry,Get Outstanding Invoices,Získat neuhrazených faktur
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +70,Sales Order {0} is not valid,Prodejní objednávky {0} není platný
DocType: Supplier Scorecard,Warn for new Request for Quotations,Upozornenie na novú žiadosť o ponuku
apps/erpnext/erpnext/utilities/activation.py +89,Purchase orders help you plan and follow up on your purchases,Objednávky pomôžu pri plánovaní a sledovaní na vaše nákupy
apps/erpnext/erpnext/setup/doctype/company/company.py +225,"Sorry, companies cannot be merged","Je nám líto, společnosti nemohou být sloučeny"
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +167,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Celkové emisie / prenosu množstvo {0} v hmotnej Request {1} \ nemôže byť väčšie než množstvo {2} pre položku {3}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +166,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: Project,% Completed,% Dokončených
,Invoiced Amount (Exculsive Tax),Fakturovaná částka (bez daně)
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Položka 2
DocType: Supplier,SUPP-,SUPP-
DocType: Training Event,Training Event,Training Event
DocType: Item,Auto re-order,Auto re-order
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Celkem Dosažená
DocType: Employee,Place of Issue,Místo vydání
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +70,Contract,Smlouva
DocType: Email Digest,Add Quote,Pridať ponuku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +868,UOM coversion factor required for UOM: {0} in Item: {1},Koeficient prepočtu MJ je potrebný k MJ: {0} v bode: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Nepřímé náklady
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Row {0}: Qty is mandatory,Row {0}: Množství je povinný
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Poľnohospodárstvo
apps/erpnext/erpnext/accounts/page/pos/pos.js +750,Sync Master Data,Sync Master Data
apps/erpnext/erpnext/public/js/setup_wizard.js +296,Your Products or Services,Vaše Produkty alebo Služby
DocType: Mode of Payment,Mode of Payment,Způsob platby
apps/erpnext/erpnext/stock/doctype/item/item.py +178,Website Image should be a public file or website URL,Webové stránky Image by mala byť verejná súboru alebo webovej stránky URL
DocType: Student Applicant,AP,AP
DocType: Purchase Invoice Item,BOM,BOM
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Jedná se o skupinu kořen položky a nelze upravovat.
DocType: Journal Entry Account,Purchase Order,Nákupná objednávka
DocType: Vehicle,Fuel UOM,palivo UOM
DocType: Warehouse,Warehouse Contact Info,Sklad Kontaktní informace
DocType: Payment Entry,Write Off Difference Amount,Odpísať Difference Suma
DocType: Purchase Invoice,Recurring Type,Typ opakujúceho sa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +410,"{0}: Employee email not found, hence email not sent","{0}: e-mail zamestnanec nebol nájdený, a preto je pošta neposlal"
DocType: Item,Foreign Trade Details,Zahraničný obchod Podrobnosti
DocType: Email Digest,Annual Income,Ročný príjem
DocType: Serial No,Serial No Details,Podrodnosti k sériovému číslu
DocType: Purchase Invoice Item,Item Tax Rate,Sazba daně položky
DocType: Student Group Student,Group Roll Number,Číslo skupiny rollov
DocType: Student Group Student,Group Roll Number,Číslo skupiny rollov
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry","Pro {0}, tak úvěrové účty mohou být propojeny na jinou položku debetní"
apps/erpnext/erpnext/projects/doctype/project/project.py +73,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Súčet všetkých váh úloha by mal byť 1. Upravte váhy všetkých úloh projektu v súlade
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +576,Delivery Note {0} is not submitted,Delivery Note {0} není předložena
apps/erpnext/erpnext/stock/get_item_details.py +151,Item {0} must be a Sub-contracted Item,Položka {0} musí být Subdodavatelské Item
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Kapitálové Vybavení
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Ceny Pravidlo je nejprve vybrána na základě ""Použít na"" oblasti, které mohou být položky, položky skupiny nebo značky."
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +215,Please set the Item Code first,Najprv nastavte kód položky
DocType: Hub Settings,Seller Website,Prodejce Website
DocType: Item,ITEM-,ITEM-
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
DocType: Appraisal Goal,Goal,Cieľ
DocType: Sales Invoice Item,Edit Description,Upraviť popis
,Team Updates,tím Updates
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +885,For Supplier,Pro Dodavatele
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Nastavení typu účtu pomáhá při výběru tohoto účtu v transakcích.
DocType: Purchase Invoice,Grand Total (Company Currency),Celkový součet (Měna společnosti)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Vytvoriť formát tlače
apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Nenašiel žiadnu položku s názvom {0}
DocType: Supplier Scorecard Criteria,Criteria Formula,Kritérium vzorca
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Celkem Odchozí
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +47,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Tam může být pouze jeden Shipping Rule Podmínka s 0 nebo prázdnou hodnotu pro ""na hodnotu"""
DocType: Authorization Rule,Transaction,Transakce
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Poznámka: Tento Nákladové středisko je Group. Nelze vytvořit účetní zápisy proti skupinám.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,Dieťa sklad existuje pre tento sklad. Nemôžete odstrániť tento sklad.
DocType: Item,Website Item Groups,Webové stránky skupiny položek
DocType: Purchase Invoice,Total (Company Currency),Total (Company meny)
apps/erpnext/erpnext/stock/utils.py +200,Serial number {0} entered more than once,Výrobní číslo {0} přihlášeno více než jednou
DocType: Depreciation Schedule,Journal Entry,Zápis do deníku
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +140,{0} items in progress,{0} položky v prebiehajúcej
DocType: Workstation,Workstation Name,Meno pracovnej stanice
DocType: Grading Scale Interval,Grade Code,grade Code
DocType: POS Item Group,POS Item Group,POS položky Group
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,E-mail Digest:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +564,BOM {0} does not belong to Item {1},BOM {0} nepatří k bodu {1}
DocType: Sales Partner,Target Distribution,Target Distribution
DocType: Salary Slip,Bank Account No.,Číslo bankového účtu
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
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
","Možno použiť premenné tabuľky výsledkov, rovnako ako: {total_score} (celkové skóre z tohto obdobia), {period_number} (počet období do súčasnosti)"
DocType: Quality Inspection Reading,Reading 8,Čtení 8
DocType: Sales Partner,Agent,Agent
DocType: Purchase Invoice,Taxes and Charges Calculation,Daně a poplatky výpočet
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Automatické odpisovanie majetku v účtovnej závierke
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Automatické odpisovanie majetku v účtovnej závierke
DocType: BOM Operation,Workstation,pracovna stanica
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Žiadosť o cenovú ponuku dodávateľa
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +123,Hardware,Technické vybavení
DocType: Sales Order,Recurring Upto,Opakujúce sa do
DocType: Attendance,HR Manager,HR Manager
apps/erpnext/erpnext/accounts/party.py +175,Please select a Company,Vyberte spoločnosť
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +61,Privilege Leave,Privilege Leave
DocType: Purchase Invoice,Supplier Invoice Date,Dátum dodávateľskej faktúry
apps/erpnext/erpnext/templates/includes/product_page.js +18,per,za
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Musíte povolit Nákupní košík
DocType: Payment Entry,Writeoff,odpísanie
DocType: Appraisal Template Goal,Appraisal Template Goal,Posouzení Template Goal
DocType: Salary Component,Earning,Príjem
DocType: Supplier Scorecard,Scoring Criteria,Kritériá hodnotenia
DocType: Purchase Invoice,Party Account Currency,Party Mena účtu
,BOM Browser,BOM Browser
DocType: Purchase Taxes and Charges,Add or Deduct,Přidat nebo Odečíst
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +82,Overlapping conditions found between:,Překrývající podmínky nalezeno mezi:
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Proti věstníku Entry {0} je již nastavena proti jiným poukaz
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Celková hodnota objednávky
apps/erpnext/erpnext/demo/setup/setup_data.py +325,Food,Jídlo
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Stárnutí Rozsah 3
DocType: Maintenance Schedule Item,No of Visits,Počet návštěv
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Plán údržby {0} existuje v porovnaní s {1}
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +32,Enrolling student,učiaci študenta
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},"Mena záverečného účtu, musí byť {0}"
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Súčet bodov za všetkých cieľov by malo byť 100. Je {0}
DocType: Project,Start and End Dates,Dátum začatia a ukončenia
,Delivered Items To Be Billed,Dodávaných výrobků fakturovaných
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Otvorená BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Warehouse nemůže být změněn pro Serial No.
DocType: Authorization Rule,Average Discount,Průměrná sleva
DocType: Purchase Invoice Item,UOM,UOM
DocType: Rename Tool,Utilities,Utilities
DocType: Purchase Invoice Item,Accounting,Účtovníctvo
DocType: Employee,EMP/,EMP /
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +107,Please select batches for batched item ,Vyberte dávky pre doručenú položku
DocType: Asset,Depreciation Schedules,odpisy Plány
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Obdobie podávania žiadostí nemôže byť alokačné obdobie vonku voľno
DocType: Activity Cost,Projects,Projekty
DocType: Payment Request,Transaction Currency,transakčné mena
apps/erpnext/erpnext/controllers/buying_controller.py +25,From {0} | {1} {2},Od {0} | {1} {2}
DocType: Production Order Operation,Operation Description,Operace Popis
DocType: Item,Will also apply to variants,Bude sa vzťahovať aj na varianty
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,"Nelze měnit Fiskální rok Datum zahájení a fiskální rok datum ukončení, jakmile fiskální rok se uloží."
DocType: Quotation,Shopping Cart,Nákupný košík
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Avg Daily Odchozí
DocType: POS Profile,Campaign,Kampaň
DocType: Supplier,Name and Type,Názov a typ
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +64,Approval Status must be 'Approved' or 'Rejected',"Stav schválení musí být ""schváleno"" nebo ""Zamítnuto"""
DocType: Purchase Invoice,Contact Person,Kontaktná osoba
apps/erpnext/erpnext/projects/doctype/task/task.py +37,'Expected Start Date' can not be greater than 'Expected End Date',"""Očakávaný Dátum Začiatku"" nemôže byť väčší ako ""Očakávaný Dátum Ukončenia"""
DocType: Course Scheduling Tool,Course End Date,Koniec Samozrejme Dátum
DocType: Holiday List,Holidays,Prázdniny
DocType: Sales Order Item,Planned Quantity,Plánované Množstvo
DocType: Purchase Invoice Item,Item Tax Amount,Částka Daně Položky
DocType: Item,Maintain Stock,Udržiavať Zásoby
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +212,Stock Entries already created for Production Order ,Fotky Položky již vytvořené pro výrobní zakázku
DocType: Employee,Prefered Email,preferovaný Email
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Čistá zmena v stálych aktív
DocType: Leave Control Panel,Leave blank if considered for all designations,Nechajte prázdne ak má platiť pre všetky zadelenia
apps/erpnext/erpnext/controllers/accounts_controller.py +676,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 +350,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,Od datetime
DocType: Email Digest,For Company,Pre spoločnosť
apps/erpnext/erpnext/config/support.py +17,Communication log.,Komunikační protokol.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +193,"Request for Quotation is disabled to access from portal, for more check portal settings.",Žiadosť o cenovú ponuku je zakázaný prístup z portálu pre viac Skontrolujte nastavenie portálu.
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Hodnota ukazovateľa skóre skóre dodávateľa
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Buying Amount,Nákup Částka
DocType: Sales Invoice,Shipping Address Name,Názov dodacej adresy
apps/erpnext/erpnext/accounts/doctype/account/account.js +58,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 +555,cannot be greater than 100,nemôže byť väčšie ako 100
apps/erpnext/erpnext/stock/doctype/item/item.py +684,Item {0} is not a stock Item,Položka {0} není skladem
DocType: Maintenance Visit,Unscheduled,Neplánovaná
DocType: Employee,Owned,Vlastník
DocType: Salary Detail,Depends on Leave Without Pay,Závisí na dovolenke bez nároku na mzdu
DocType: Pricing Rule,"Higher the number, higher the priority","Vyšší číslo, vyšší priorita"
,Purchase Invoice Trends,Trendy přijatách faktur
DocType: Employee,Better Prospects,Lepší vyhlídky
apps/erpnext/erpnext/stock/doctype/batch/batch.py +114,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Riadok # {0}: Dávka {1} má iba {2} qty. Vyberte inú dávku, ktorá má {3} k dispozícii, alebo rozdeľte riadok do viacerých riadkov a doručte / vydávajte z viacerých šarží"
DocType: Vehicle,License Plate,Poznávacia značka
DocType: Appraisal,Goals,Ciele
DocType: Warranty Claim,Warranty / AMC Status,Záruka / AMC Status
,Accounts Browser,Účty Browser
DocType: Payment Entry Reference,Payment Entry Reference,Platba Vstup referencie
DocType: GL Entry,GL Entry,Vstup GL
DocType: HR Settings,Employee Settings,Nastavení zaměstnanců
,Batch-Wise Balance History,Batch-Wise Balance History
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Nastavenie tlače aktualizované v príslušnom formáte tlači
DocType: Package Code,Package Code,code Package
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +74,Apprentice,Učeň
DocType: Purchase Invoice,Company GSTIN,Spoločnosť GSTIN
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Záporné množstvo nie je dovolené
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Tax detail tabulka staženy z položky pána jako řetězec a uložené v této oblasti.
 Používá se daní a poplatků"
DocType: Supplier Scorecard Period,SSC-,SSC-
apps/erpnext/erpnext/hr/doctype/employee/employee.py +154,Employee cannot report to himself.,Zamestnanec nemôže reportovať sám sebe.
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","V případě, že účet je zamrzlý, položky mohou omezeným uživatelům."
DocType: Email Digest,Bank Balance,Bankový zostatok
apps/erpnext/erpnext/accounts/party.py +238,Accounting Entry for {0}: {1} can only be made in currency: {2},Účtovný záznam pre {0}: {1} môžu vykonávať len v mene: {2}
DocType: Job Opening,"Job profile, qualifications required etc.","Profil Job, požadované kvalifikace atd."
DocType: Journal Entry Account,Account Balance,Zůstatek na účtu
apps/erpnext/erpnext/config/accounts.py +185,Tax Rule for transactions.,Daňové Pravidlo pre transakcie.
DocType: Rename Tool,Type of document to rename.,Typ dokumentu na premenovanie.
apps/erpnext/erpnext/public/js/setup_wizard.js +316,We buy this Item,Táto položka sa kupuje
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Zákazník je potrebná proti pohľadávok účtu {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Spolu dane a poplatky (v peňažnej mene firmy)
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Ukázať P &amp; L zostatky neuzavretý fiškálny rok je
DocType: Shipping Rule,Shipping Account,Dodací účet
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Účet {2} je neaktívny
apps/erpnext/erpnext/utilities/activation.py +80,Make Sales Orders to help you plan your work and deliver on-time,"Urobiť Predajné objednávky, ktoré vám pomôžu plánovať svoju prácu a doručiť na čas"
DocType: Quality Inspection,Readings,Čtení
DocType: Stock Entry,Total Additional Costs,Celkom Dodatočné náklady
DocType: Course Schedule,SH,SH
DocType: BOM,Scrap Material Cost(Company Currency),Šrot materiálové náklady (Company mena)
apps/erpnext/erpnext/public/js/setup_wizard.js +307,Sub Assemblies,Podsestavy
DocType: Asset,Asset Name,asset Name
DocType: Project,Task Weight,úloha Hmotnosť
DocType: Shipping Rule Condition,To Value,Chcete-li hodnota
DocType: Asset Movement,Stock Manager,Manažér zásob
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +144,Source warehouse is mandatory for row {0},Source sklad je povinná pro řadu {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +809,Packing Slip,List k balíku
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Pronájem kanceláře
apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Nastavenie SMS brány
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +60,Import Failed!,Import se nezdařil!
apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Žádná adresa přidán dosud.
DocType: Workstation Working Hour,Workstation Working Hour,Pracovní stanice Pracovní Hour
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +94,Analyst,Analytik
DocType: Item,Inventory,Inventář
DocType: Item,Sales Details,Predajné podrobnosti
DocType: Quality Inspection,QI-,QI-
DocType: Opportunity,With Items,S položkami
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,V Množství
DocType: School Settings,Validate Enrolled Course for Students in Student Group,Overiť zapísaný kurz pre študentov v študentskej skupine
DocType: Notification Control,Expense Claim Rejected,Uhrazení výdajů zamítnuto
DocType: Item,Item Attribute,Položka Atribut
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +116,Government,Vláda
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Náklady na poistné {0} už existuje pre jázd
apps/erpnext/erpnext/public/js/setup_wizard.js +55,Institute Name,Meno Institute
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,"Prosím, zadajte splácanie Čiastka"
apps/erpnext/erpnext/config/stock.py +300,Item Variants,Varianty Položky
DocType: Company,Services,Služby
DocType: HR Settings,Email Salary Slip to Employee,Email výplatnej páske pre zamestnancov
DocType: Cost Center,Parent Cost Center,Nadřazené Nákladové středisko
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1002,Select Possible Supplier,Zvoľte Možné dodávateľa
DocType: Sales Invoice,Source,Zdroj
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Zobraziť uzatvorené
DocType: Leave Type,Is Leave Without Pay,Je odísť bez Pay
apps/erpnext/erpnext/stock/doctype/item/item.py +236,Asset Category is mandatory for Fixed Asset item,Asset kategória je povinný pre položku investičného majetku
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,No records found in the Payment table,Nalezené v tabulce platby Žádné záznamy
apps/erpnext/erpnext/schools/utils.py +19,This {0} conflicts with {1} for {2} {3},Táto {0} je v rozpore s {1} o {2} {3}
DocType: Student Attendance Tool,Students HTML,študenti HTML
DocType: POS Profile,Apply Discount,použiť zľavu
DocType: GST HSN Code,GST HSN Code,GST kód HSN
DocType: Employee External Work History,Total Experience,Celková zkušenost
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,otvorené projekty
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +286,Packing Slip(s) cancelled,Balení Slip (y) zrušeno
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +31,Cash Flow from Investing,Peňažný tok z investičných
DocType: Program Course,Program Course,program kurzu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Nákladní a Spediční Poplatky
DocType: Homepage,Company Tagline for website homepage,Firma fb na titulnej stránke webu
DocType: Item Group,Item Group Name,Položka Název skupiny
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Zaujatý
DocType: Student,Date of Leaving,Dátum Odchádzanie
DocType: Pricing Rule,For Price List,Pro Ceník
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Executive Search
apps/erpnext/erpnext/utilities/activation.py +61,Create Leads,Vytvoriť vedie
DocType: Maintenance Schedule,Schedules,Plány
DocType: Purchase Invoice Item,Net Amount,Čistá suma
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +143,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} nebola odoslaná, takže akciu nemožno dokončiť"
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail No
DocType: Landed Cost Voucher,Additional Charges,dodatočné poplatky
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Dodatočná zľava Suma (Mena Company)
DocType: Supplier Scorecard,Supplier Scorecard,Hodnotiaca tabuľka dodávateľa
apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,"Prosím, vytvořte nový účet z grafu účtů."
,Support Hour Distribution,Distribúcia hodín podpory
DocType: Maintenance Visit,Maintenance Visit,Maintenance Visit
DocType: Student,Leaving Certificate Number,maturita číslo
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,K dispozícii dávky Množstvo v sklade
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Aktualizácia Print Format
DocType: Landed Cost Voucher,Landed Cost Help,Přistálo Náklady Help
DocType: Purchase Invoice,Select Shipping Address,Zvoľte adresu pre dodanie
DocType: Leave Block List,Block Holidays on important days.,Blokové Dovolená na významných dnů.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Pohledávky Shrnutí
DocType: Employee Loan,Monthly Repayment Amount,Mesačné splátky čiastka
apps/erpnext/erpnext/hr/doctype/employee/employee.py +191,Please set User ID field in an Employee record to set Employee Role,Prosím nastavte používateľské ID v karte zamestnanca ak chcete umožniť rolu zamestnanca
DocType: UOM,UOM Name,Názov Mernej Jednotky
DocType: GST HSN Code,HSN Code,Kód HSN
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Výše příspěvku
DocType: Purchase Invoice,Shipping Address,Dodacia adresa
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,"Tento nástroj vám pomůže aktualizovat nebo opravit množství a ocenění zásob v systému. To se obvykle používá k synchronizaci hodnot systému a to, co ve skutečnosti existuje ve vašich skladech."
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,"Ve slovech budou viditelné, jakmile uložíte doručení poznámku."
DocType: Expense Claim,EXP,EXP
apps/erpnext/erpnext/config/stock.py +200,Brand master.,Master Značky
apps/erpnext/erpnext/schools/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Študent {0} - {1} objaví viackrát za sebou {2} {3}
DocType: Program Enrollment Tool,Program Enrollments,program Prihlášky
DocType: Sales Invoice Item,Brand Name,Jméno značky
DocType: Purchase Receipt,Transporter Details,Transporter Podrobnosti
apps/erpnext/erpnext/accounts/page/pos/pos.js +2587,Default warehouse is required for selected item,Predvolené sklad je vyžadované pre vybraná položka
apps/erpnext/erpnext/public/js/setup_wizard.js +310,Box,Krabica
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +999,Possible Supplier,možné Dodávateľ
DocType: Budget,Monthly Distribution,Měsíční Distribution
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Přijímač Seznam je prázdný. Prosím vytvořte přijímače Seznam
DocType: Production Plan Sales Order,Production Plan Sales Order,Výrobní program prodejní objednávky
DocType: Sales Partner,Sales Partner Target,Sales Partner Target
DocType: Loan Type,Maximum Loan Amount,Maximálna výška úveru
DocType: Pricing Rule,Pricing Rule,Cenové pravidlo
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +53,Duplicate roll number for student {0},Duplicitné číslo rolky pre študenta {0}
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +53,Duplicate roll number for student {0},Duplicitné číslo rolky pre študentov {0}
DocType: Budget,Action if Annual Budget Exceeded,Akčný Pokiaľ ide o ročný rozpočet prekročený
apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Materiál Žiadosť o príkaze k nákupu
DocType: Shopping Cart Settings,Payment Success URL,Platba Úspech URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +80,Row # {0}: Returned Item {1} does not exists in {2} {3},Riadok # {0}: vrátenej položky {1} neexistuje v {2} {3}
DocType: Purchase Receipt,PREC-,PREC-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Bankové účty
,Bank Reconciliation Statement,Bank Odsouhlasení prohlášení
,Lead Name,Meno Obchodnej iniciatívy
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/config/stock.py +305,Opening Stock Balance,Otvorenie Sklad Balance
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} môže byť uvedené iba raz
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +368,Not allowed to tranfer more {0} than {1} against Purchase Order {2},"Nie je povolené, aby transfer viac {0} ako {1} proti objednanie {2}"
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,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 +555,Manufacturing Quantity is mandatory,Výrobné množstvo je povinné
DocType: Employee Loan,Repayment Method,splácanie Method
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Ak je zaškrtnuté, domovská stránka bude východiskový bod skupina pre webové stránky"
DocType: Quality Inspection Reading,Reading 4,Čtení 4
apps/erpnext/erpnext/config/hr.py +127,Claims for company expense.,Nároky na náklady firmy.
apps/erpnext/erpnext/utilities/activation.py +116,"Students are at the heart of the system, add all your students","Študenti sú v centre systému, pridajte všetky svoje študentov"
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Riadok # {0}: dátum Svetlá {1} nemôže byť pred Cheque Dátum {2}
DocType: Company,Default Holiday List,Výchozí Holiday Seznam
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,Row {0}: From Time and To Time of {1} is overlapping with {2},Riadok {0}: čas od času aj na čas z {1} sa prekrýva s {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Zásoby Pasíva
DocType: Purchase Invoice,Supplier Warehouse,Dodavatel Warehouse
DocType: Opportunity,Contact Mobile No,Kontakt Mobil
,Material Requests for which Supplier Quotations are not created,Materiál Žádosti o které Dodavatel citace nejsou vytvořeny
DocType: Student Group,Set 0 for no limit,Nastavte 0 pre žiadny limit
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +141,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,"V deň, keď (y), na ktoré žiadate o povolenie sú prázdniny. Nemusíte požiadať o voľno."
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Znovu poslať e-mail Payment
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,novú úlohu
apps/erpnext/erpnext/utilities/activation.py +72,Make Quotation,Vytvoriť ponuku
apps/erpnext/erpnext/config/selling.py +216,Other Reports,Ostatné správy
DocType: Dependent Task,Dependent Task,Závislý Task
apps/erpnext/erpnext/stock/doctype/item/item.py +402,Conversion factor for default Unit of Measure must be 1 in row {0},"Konverzní faktor pro výchozí měrnou jednotku, musí být 1 v řádku {0}"
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +208,Leave of type {0} cannot be longer than {1},Leave typu {0} nemůže být delší než {1}
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Skúste plánovanie operácií pre X dní vopred.
DocType: HR Settings,Stop Birthday Reminders,Zastaviť pripomenutie narodenín
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +250,Please set Default Payroll Payable Account in Company {0},"Prosím nastaviť predvolený účet mzdy, splatnú v spoločnosti {0}"
DocType: SMS Center,Receiver List,Přijímač Seznam
apps/erpnext/erpnext/accounts/page/pos/pos.js +1074,Search Item,hľadanie položky
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Spotřebovaném množství
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Čistá zmena v hotovosti
DocType: Assessment Plan,Grading Scale,stupnica
apps/erpnext/erpnext/stock/doctype/item/item.py +397,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Měrná jednotka {0} byl zadán více než jednou v konverzním faktorem tabulce
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +611,Already completed,už boli dokončené
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Skladom v ruke
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Platba Dopyt už existuje {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Náklady na vydaných položek
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +353,Quantity must not be more than {0},Množství nesmí být větší než {0}
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Predchádzajúci finančný rok nie je uzavretý
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Staroba (dni)
DocType: Quotation Item,Quotation Item,Položka ponuky
DocType: Customer,Customer POS Id,ID zákazníka POS
DocType: Account,Account Name,Názov účtu
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Dátum OD nemôže byť väčší ako dátum DO
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,Pořadové číslo {0} {1} množství nemůže být zlomek
apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Dodavatel Type master.
DocType: Purchase Order Item,Supplier Part Number,Dodavatel Číslo dílu
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +104,Conversion rate cannot be 0 or 1,Míra konverze nemůže být 0 nebo 1
DocType: Sales Invoice,Reference Document,referenčný dokument
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +213,{0} {1} is cancelled or stopped,{0} {1} je zrušená alebo zastavená
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Delivery Note,Vehicle Dispatch Date,Vozidlo Dispatch Datum
DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Receipt {0} is not submitted,Doklad o koupi {0} není předložena
DocType: Company,Default Payable Account,Výchozí Splatnost účtu
apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Nastavení pro on-line nákupního košíku, jako jsou pravidla dopravu, ceník atd"
apps/erpnext/erpnext/controllers/website_list_for_contact.py +111,{0}% Billed,{0}% fakturované
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Reserved Množství
DocType: Party Account,Party Account,Party účtu
apps/erpnext/erpnext/config/setup.py +122,Human Resources,Lidské zdroje
DocType: Lead,Upper Income,Horní příjmů
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +13,Reject,Odmietnuť
DocType: Journal Entry Account,Debit in Company Currency,Debetnej v spoločnosti Mena
DocType: BOM Item,BOM Item,BOM Item
DocType: Appraisal,For Employee,Pro zaměstnance
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Urobiť vyplácanie Entry
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Riadok {0}: Advance proti dodávateľom musí byť odpísať
DocType: Company,Default Values,Predvolené hodnoty
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +61,{frequency} Digest,{Frekvencia} Digest
DocType: Expense Claim,Total Amount Reimbursed,Celkovej sumy vyplatenej
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,To je založené na protokoloch proti tomuto vozidlu. Pozri časovú os nižšie podrobnosti
apps/erpnext/erpnext/schools/doctype/fees/fees.js +41,Collect,Zbierať
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +86,Against Supplier Invoice {0} dated {1},Proti faktuře dodavatele {0} ze dne {1}
DocType: Customer,Default Price List,Výchozí Ceník
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +244,Asset Movement record {0} created,Záznam Asset Pohyb {0} vytvoril
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Nemožno odstrániť fiškálny rok {0}. Fiškálny rok {0} je nastavený ako predvolený v globálnom nastavení
DocType: Journal Entry,Entry Type,Entry Type
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Žiaden plán hodnotenia nesúvisí s touto skupinou
,Customer Credit Balance,Zákazník Credit Balance
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Čistá Zmena účty záväzkov
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 +142,Update bank payment dates with journals.,"Aktualizujte bankovní platební termín, časopisů."
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Stanovenie ceny
DocType: Quotation,Term Details,Termín Podrobnosti
DocType: Project,Total Sales Cost (via Sales Order),Celkové predajné náklady (prostredníctvom objednávky predaja)
DocType: Project,Total Sales Cost (via Sales Order),Celkové predajné náklady (prostredníctvom objednávky predaja)
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +29,Cannot enroll more than {0} students for this student group.,Nemôže prihlásiť viac ako {0} študentov na tejto študentské skupiny.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Počet iniciatív
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Počet iniciatív
apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} musí byť väčšia ako 0
DocType: Manufacturing Settings,Capacity Planning For (Days),Plánovanie kapacít Pro (dni)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Obstarávanie
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,None of the items have any change in quantity or value.,Žiadna z týchto položiek nemá zmenu v množstve alebo hodnote.
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Povinné pole - Program
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Povinné pole - Program
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Záruční reklamace
,Lead Details,Podrobnosti Obchodnej iniciatívy
DocType: Salary Slip,Loan repayment,splácania úveru
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: Accounts Settings,Unlink Payment on Cancellation of Invoice,Odpojiť Platba o zrušení faktúry
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Aktuálny stav km vstúpil by mala byť väčšia ako počiatočný stav kilometrov {0}
DocType: Shipping Rule Country,Shipping Rule Country,Prepravné Pravidlo Krajina
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Priepustky a dochádzky
DocType: Maintenance Visit,Partially Completed,Částečně Dokončeno
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Dodávateľ&gt; Typ dodávateľa
DocType: Leave Type,Include holidays within leaves as leaves,Zahrnúť dovolenku v listoch sú listy
DocType: Sales Invoice,Packed Items,Zabalené položky
apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Reklamační proti sériového čísla
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +65,'Total',&quot;Celkom&quot;
DocType: Shopping Cart Settings,Enable Shopping Cart,Povolit Nákupní košík
DocType: Employee,Permanent Address,Trvalé bydliště
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Vyplatená záloha proti {0} {1} nemôže byť väčšia \ než Grand Celkom {2}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,"Prosím, vyberte položku kód"
DocType: Student Sibling,Studying in Same Institute,Štúdium v Same ústave
DocType: Territory,Territory Manager,Oblastní manažer
DocType: Packed Item,To Warehouse (Optional),Warehouse (voliteľné)
DocType: Payment Entry,Paid Amount (Company Currency),Zaplatená suma (Company meny)
DocType: Purchase Invoice,Additional Discount,Ďalšie zľavy
DocType: Selling Settings,Selling Settings,Nastavenia pre Predaj
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +39,Online Auctions,Aukce online
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +98,Please specify either Quantity or Valuation Rate or both,"Uveďte prosím buď Množstvo alebo Pomer ocenenia, alebo obidve."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +17,Fulfillment,splnenie
apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Zobraziť Košík
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Marketingové náklady
,Item Shortage Report,Položka Nedostatek Report
apps/erpnext/erpnext/stock/doctype/item/item.js +265,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Hmotnosť je uvedená, \n uveďte prosím aj ""váhu MJ"""
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Materiál Žádost používá k výrobě této populace Entry
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Vedľa Odpisy Dátum je povinné pre nové aktívum
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Samostatná skupina kurzov pre každú dávku
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Samostatná skupina kurzov pre každú dávku
apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Single jednotka položky.
DocType: Fee Category,Fee Category,poplatok Kategórie
,Student Fee Collection,Študent Fee Collection
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Ujistěte se účetní položka pro každý pohyb zásob
DocType: Leave Allocation,Total Leaves Allocated,Celkem Leaves Přidělené
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +159,Warehouse required at Row No {0},Warehouse vyžadované pri Row No {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +124,Please enter valid Financial Year Start and End Dates,Zadajte platné dátumy začiatku a konca finančného roka
DocType: Employee,Date Of Retirement,Datum odchodu do důchodu
DocType: Upload Attendance,Get Template,Získat šablonu
DocType: Material Request,Transferred,prevedená
DocType: Vehicle,Doors,dvere
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +206,ERPNext Setup Complete!,Nastavenie ERPNext dokončené!
DocType: Course Assessment Criteria,Weightage,Weightage
DocType: Purchase Invoice,Tax Breakup,Daňové rozdelenie
DocType: Packing Slip,PS-,PS-
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}: Je potrebné nákladového strediska pre &#39;zisku a straty &quot;účtu {2}. Prosím nastaviť predvolené nákladového strediska pre spoločnosť.
apps/erpnext/erpnext/selling/doctype/customer/customer.py +115,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ů"
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Nový kontakt
DocType: Territory,Parent Territory,Parent Territory
DocType: Sales Invoice,Place of Supply,Miesto dodávky
DocType: Quality Inspection Reading,Reading 2,Čtení 2
DocType: Stock Entry,Material Receipt,Příjem materiálu
DocType: Homepage,Products,Výrobky
DocType: Announcement,Instructor,inštruktor
DocType: Employee,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ak je táto položka má varianty, potom to nemôže byť vybraná v predajných objednávok atď"
DocType: Lead,Next Contact By,Další Kontakt By
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +293,Quantity required for Item {0} in row {1},Množství požadované pro bodě {0} v řadě {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},"Sklad {0} nelze smazat, protože existuje množství k položce {1}"
DocType: Quotation,Order Type,Typ objednávky
DocType: Purchase Invoice,Notification Email Address,Oznámení e-mailová adresa
,Item-wise Sales Register,Item-moudrý Sales Register
DocType: Asset,Gross Purchase Amount,Gross Suma nákupu
DocType: Asset,Depreciation Method,odpisy Metóda
apps/erpnext/erpnext/accounts/page/pos/pos.js +713,Offline,offline
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Je to poplatek v ceně základní sazbě?
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Celkem Target
DocType: Job Applicant,Applicant for a Job,Žadatel o zaměstnání
DocType: Production Plan Material Request,Production Plan Material Request,Výroba Dopyt Plán Materiál
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +235,No Production Orders created,Žádné výrobní zakázky vytvořené
DocType: Stock Reconciliation,Reconciliation JSON,Odsouhlasení JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Příliš mnoho sloupců. Export zprávu a vytiskněte jej pomocí aplikace tabulky.
DocType: Purchase Invoice Item,Batch No,Č. šarže
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Povoliť viac Predajné objednávky proti Zákazníka Objednávky
DocType: Student Group Instructor,Student Group Instructor,Inštruktor skupiny študentov
DocType: Student Group Instructor,Student Group Instructor,Inštruktor skupiny študentov
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile Žiadne
apps/erpnext/erpnext/setup/doctype/company/company.py +204,Main,Hlavné
apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant,Varianta
DocType: Naming Series,Set prefix for numbering series on your transactions,Nastavit prefix pro číslování série na vašich transakcí
DocType: Employee Attendance Tool,Employees HTML,Zamestnanci HTML
apps/erpnext/erpnext/stock/doctype/item/item.py +416,Default BOM ({0}) must be active for this item or its template,Predvolené BOM ({0}) musí byť aktívna pre túto položku alebo jeho šablóny
DocType: Employee,Leave Encashed?,Ponechte zpeněžení?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Opportunity Ze hřiště je povinné
DocType: Email Digest,Annual Expenses,ročné náklady
DocType: Item,Variants,Varianty
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1078,Make Purchase Order,Vytvoriť odoslanú objednávku
DocType: SMS Center,Send To,Odoslať na
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},Není dost bilance dovolenou na vstup typ {0}
DocType: Payment Reconciliation Payment,Allocated amount,Přidělené sumy
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,Inventúra zásob
DocType: Territory,Territory Name,Území Name
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +177,Work-in-Progress Warehouse is required before Submit,Work-in-Progress sklad je zapotřebí před Odeslat
apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Žadatel o zaměstnání.
DocType: Purchase Order Item,Warehouse and Reference,Sklad a reference
DocType: Supplier,Statutory info and other general information about your Supplier,Statutární info a další obecné informace o váš dodavatel
DocType: Item,Serial Nos and Batches,Sériové čísla a dávky
DocType: Item,Serial Nos and Batches,Sériové čísla a dávky
apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Sila študentskej skupiny
apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Sila študentskej skupiny
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +246,Against Journal Entry {0} does not have any unmatched {1} entry,Proti věstníku Vstup {0} nemá bezkonkurenční {1} vstupu
apps/erpnext/erpnext/config/hr.py +137,Appraisals,ocenenie
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Duplicitní Pořadové číslo vstoupil k bodu {0}
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Podmínka pro pravidla dopravy
apps/erpnext/erpnext/hr/doctype/employee/employee.py +161,Please enter ,Prosím zadajte
apps/erpnext/erpnext/controllers/accounts_controller.py +436,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Nemožno overbill k bodu {0} v rade {1} viac ako {2}. Aby bolo možné cez-fakturácie, je potrebné nastaviť pri nákupe Nastavenie"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +212,Please set filter based on Item or Warehouse,Prosím nastaviť filter na základe výtlačku alebo v sklade
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Čistá hmotnost tohoto balíčku. (Automaticky vypočítá jako součet čisté váhy položek)
DocType: Sales Order,To Deliver and Bill,Dodať a Bill
DocType: Student Group,Instructors,inštruktori
DocType: GL Entry,Credit Amount in Account Currency,Kreditné Čiastka v mene účtu
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +561,BOM {0} must be submitted,BOM {0} musí být předloženy
DocType: Authorization Control,Authorization Control,Autorizace Control
apps/erpnext/erpnext/controllers/buying_controller.py +306,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Riadok # {0}: zamietnutie Warehouse je povinná proti zamietnutej bodu {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +782,Payment,Splátka
apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Warehouse {0} nie je prepojený s žiadnym účtom, uveďte účet v zozname skladov alebo nastavte predvolený inventárny účet v spoločnosti {1}."
apps/erpnext/erpnext/utilities/activation.py +79,Manage your orders,Spravovať svoje objednávky
DocType: Production Order Operation,Actual Time and Cost,Skutečný Čas a Náklady
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +54,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Materiál Žádost maximálně {0} lze k bodu {1} na odběratele {2}
DocType: Course,Course Abbreviation,skratka ihrisko
DocType: Student Leave Application,Student Leave Application,Študent nechať aplikáciu
DocType: Item,Will also apply for variants,Bude platiť aj pre varianty
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +160,"Asset cannot be cancelled, as it is already {0}","Asset nemožno zrušiť, pretože je už {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Zamestnancov {0} o pol dňa na {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Celkom pracovná doba by nemala byť väčšia ako maximálna pracovnej doby {0}
apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Kdy
apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Bundle položky v okamžiku prodeje.
DocType: Quotation Item,Actual Qty,Skutečné Množství
DocType: Sales Invoice Item,References,Referencie
DocType: Quality Inspection Reading,Reading 10,Čtení 10
apps/erpnext/erpnext/public/js/setup_wizard.js +297,"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.","Vypíšte zopár produktov alebo služieb, ktoré predávate alebo kupujete. Po spustení systému sa presvečte, či majú tieto položky správne nastavenú mernú jednotku, kategóriu a ostatné vlastnosti."
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/setup_wizard/install_fixtures.py +98,Associate,Spolupracovník
DocType: Company,Sales Target,Cieľ predaja
DocType: Asset Movement,Asset Movement,asset Movement
apps/erpnext/erpnext/accounts/page/pos/pos.js +2121,New Cart,new košík
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Položka {0} není serializovat položky
DocType: SMS Center,Create Receiver List,Vytvořit přijímače seznam
DocType: Vehicle,Wheels,kolesá
DocType: Packing Slip,To Package No.,Balit No.
DocType: Production Planning Tool,Material Requests,materiál Žiadosti
DocType: Warranty Claim,Issue Date,Datum vydání
DocType: Activity Cost,Activity Cost,Náklady Aktivita
DocType: Sales Invoice Timesheet,Timesheet Detail,časového rozvrhu Detail
DocType: Purchase Receipt Item Supplied,Consumed Qty,Spotřeba Množství
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +52,Telecommunications,Telekomunikace
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)"
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Učinit vstup platby
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +126,Quantity for Item {0} must be less than {1},Množství k bodu {0} musí být menší než {1}
,Sales Invoice Trends,Prodejní faktury Trendy
DocType: Leave Application,Apply / Approve Leaves,Použít / Schválit listy
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +23,For,Pre
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +150,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',"Se může vztahovat řádku, pouze pokud typ poplatku je ""On předchozí řady Částka"" nebo ""předchozí řady Total"""
DocType: Sales Order Item,Delivery Warehouse,Dodávka Warehouse
apps/erpnext/erpnext/config/accounts.py +243,Tree of financial Cost Centers.,Strom Nákl.stredisko finančných.
apps/erpnext/erpnext/hr/doctype/employee/employee.py +23,Please setup Employee Naming System in Human Resource &gt; HR Settings,"Prosím, nastavte systém pomenovania zamestnancov v oblasti Ľudské zdroje&gt; Osobné nastavenie"
DocType: Serial No,Delivery Document No,Dodávka dokument č
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +190,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Prosím nastavte &quot;/ STRATY zisk z aktív odstraňovaním&quot; vo firme {0}
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 +33,Item {0} appears multiple times in Price List {1},Položka {0} se objeví několikrát v Ceníku {1}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +40,"Selling must be checked, if Applicable For is selected as {0}","Prodej musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
DocType: Production Plan Material Request,Material Request Date,Materiál Request Date
DocType: Purchase Order Item,Supplier Quotation Item,Položka dodávateľskej ponuky
DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Zakáže vytváranie časových protokolov proti výrobnej zákazky. Transakcie nesmú byť sledované proti výrobnej zákazky
DocType: Student,Student Mobile Number,Študent Číslo mobilného telefónu
DocType: Item,Has Variants,Má varianty
apps/erpnext/erpnext/public/js/utils.js +208,You have already selected items from {0} {1},Už ste vybrané položky z {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Název měsíční výplatou
apps/erpnext/erpnext/stock/doctype/batch/batch.py +25,Batch ID is mandatory,Číslo šarže je povinné
apps/erpnext/erpnext/stock/doctype/batch/batch.py +25,Batch ID is mandatory,Číslo šarže je povinné
DocType: Sales Person,Parent Sales Person,Parent obchodník
DocType: Purchase Invoice,Recurring Invoice,Opakujúca sa faktúra
apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Správa projektov
DocType: Supplier,Supplier of Goods or Services.,Dodavatel zboží nebo služeb.
DocType: Budget,Fiscal Year,Fiškálny rok
DocType: Vehicle Log,Fuel Price,palivo Cena
DocType: Budget,Budget,Rozpočet
apps/erpnext/erpnext/stock/doctype/item/item.py +233,Fixed Asset Item must be a non-stock item.,Fixed Asset položky musia byť non-skladová položka.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Rozpočet nemožno priradiť proti {0}, pretože to nie je výnos alebo náklad účet"
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Dosažená
DocType: Student Admission,Application Form Route,prihláška Trasa
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Territory / Customer
apps/erpnext/erpnext/public/js/setup_wizard.js +247,e.g. 5,napríklad 5
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,"Nechať Typ {0} nemôže byť pridelená, pretože sa odísť bez zaplatenia"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +166,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: Lead,Follow Up,Nasleduj
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 +69,Item {0} is not setup for Serial Nos. Check Item master,"Položka {0} není nastavení pro Serial č. Zkontrolujte, zda master položku"
DocType: Maintenance Visit,Maintenance Time,Údržba Time
,Amount to Deliver,"Suma, ktorá má dodávať"
apps/erpnext/erpnext/public/js/setup_wizard.js +304,A Product or Service,Produkt alebo Služba
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,"Termínovaný Dátum začatia nemôže byť skôr ako v roku dátum začiatku akademického roka, ku ktorému termín je spojená (akademický rok {}). Opravte dáta a skúste to znova."
DocType: Guardian,Guardian Interests,Guardian záujmy
DocType: Naming Series,Current Value,Current Value
apps/erpnext/erpnext/controllers/accounts_controller.py +253,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Niekoľko fiškálnych rokov existujú pre dáta {0}. Prosím nastavte spoločnosť vo fiškálnom roku
DocType: School Settings,Instructor Records to be created by,"Záznamy inštruktorov, ktoré vytvorí"
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +233,{0} created,{0} vytvoril
DocType: Delivery Note Item,Against Sales Order,Proti přijaté objednávce
,Serial No Status,Serial No Status
DocType: Payment Entry Reference,Outstanding,vynikajúci
DocType: Supplier,Warn POs,Upozorňujte organizácie výrobcov
,Daily Timesheet Summary,Denný časový rozvrh Súhrn
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"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}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,To je založené na akciovom pohybu. Pozri {0} Podrobnosti
DocType: Pricing Rule,Selling,Predaj
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +375,Amount {0} {1} deducted against {2},Množstvo {0} {1} odpočítať proti {2}
DocType: Employee,Salary Information,Vyjednávání o platu
DocType: Sales Person,Name and Employee ID,Meno a ID zamestnanca
apps/erpnext/erpnext/accounts/party.py +303,Due Date cannot be before Posting Date,Datum splatnosti nesmí být před odesláním Datum
DocType: Website Item Group,Website Item Group,Website Item Group
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Odvody a dane
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,"Prosím, zadejte Referenční den"
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} platobné položky nemôžu byť filtrované podľa {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,"Tabuľka k Položke, která sa zobrazí na webových stránkách"
DocType: Purchase Order Item Supplied,Supplied Qty,Dodávané Množstvo
DocType: Purchase Order Item,Material Request Item,Materiál Žádost o bod
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Strom skupiny položek.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +160,Cannot refer row number greater than or equal to current row number for this Charge type,Nelze odkazovat číslo řádku větší nebo rovnou aktuální číslo řádku pro tento typ Charge
DocType: Asset,Sold,Predané
,Item-wise Purchase History,Item-moudrý Historie nákupů
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"Prosím, klikněte na ""Generovat Schedule"", aby přinesla Pořadové číslo přidán k bodu {0}"
DocType: Account,Frozen,Zmražený
,Open Production Orders,Otevřené výrobní zakázky
DocType: Sales Invoice Payment,Base Amount (Company Currency),Základná suma (Company Currency)
DocType: Payment Reconciliation Payment,Reference Row,referenčnej Row
DocType: Installation Note,Installation Time,Instalace Time
DocType: Sales Invoice,Accounting Details,Účtovné Podrobnosti
apps/erpnext/erpnext/setup/doctype/company/company.js +74,Delete all the Transactions for this Company,Odstráňte všetky transakcie pre túto spoločnosť
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +190,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} není dokončen {2} Množství hotových výrobků ve výrobním procesu objednávky # {3}. Prosím aktualizujte provozní stav přes čas protokoly
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investice
DocType: Issue,Resolution Details,Rozlišení Podrobnosti
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,alokácie
DocType: Item Quality Inspection Parameter,Acceptance Criteria,Kritéria přijetí
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +163,Please enter Material Requests in the above table,"Prosím, zadajte Žiadosti materiál vo vyššie uvedenej tabuľke"
DocType: Item Attribute,Attribute Name,Názov atribútu
DocType: BOM,Show In Website,Zobraziť na webstránke
DocType: Shopping Cart Settings,Show Quantity in Website,Vykazujú množstvo webových stránok
DocType: Employee Loan Application,Total Payable Amount,Celková suma Splatné
DocType: Task,Expected Time (in hours),Predpokladaná doba (v hodinách)
DocType: Item Reorder,Check in (group),Check in (skupina)
,Qty to Order,Množství k objednávce
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Účet hlavu pod záväzkom alebo vlastným imaním, v ktorom budú Zisk / strata rezervovať"
apps/erpnext/erpnext/config/projects.py +30,Gantt chart of all tasks.,Ganttův diagram všech zadaných úkolů.
DocType: Opportunity,Mins to First Response,Min First Response
DocType: Pricing Rule,Margin Type,margin Type
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} hodín
DocType: Course,Default Grading Scale,Predvolené Stupnica
DocType: Appraisal,For Employee Name,Pro jméno zaměstnance
DocType: Holiday List,Clear Table,Clear Table
DocType: C-Form Invoice Detail,Invoice No,Faktúra č.
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +344,Make Payment,Vykonať platbu
DocType: Room,Room Name,Room Meno
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +100,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Nechajte nemožno aplikovať / zrušená pred {0}, pretože rovnováha dovolenky už bolo carry-odovzdávané v budúcej pridelenie dovolenku záznamu {1}"
DocType: Activity Cost,Costing Rate,Kalkulácie Rate
apps/erpnext/erpnext/config/selling.py +229,Customer Addresses And Contacts,Adresy zákazníkov a kontakty
,Campaign Efficiency,Efektívnosť kampane
,Campaign Efficiency,Efektívnosť kampane
DocType: Discussion,Discussion,diskusia
DocType: Payment Entry,Transaction ID,ID transakcie
DocType: Employee,Resignation Letter Date,Rezignace Letter Datum
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Pravidla pro stanovení sazeb jsou dále filtrována na základě množství.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +333,Please set the Date Of Joining for employee {0},Nastavte dátum založenia pre zamestnanca {0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +333,Please set the Date Of Joining for employee {0},Nastavte dátum založenia pre zamestnanca {0}
DocType: Task,Total Billing Amount (via Time Sheet),Celková suma Billing (cez Time Sheet)
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Repeat Customer Příjmy
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +175,{0} ({1}) must have role 'Expense Approver',"{0} ({1}), musí mať úlohu ""Schvalovateľ výdajov"""
apps/erpnext/erpnext/public/js/setup_wizard.js +310,Pair,Pár
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +902,Select BOM and Qty for Production,Vyberte BOM a Množstvo na výrobu
DocType: Asset,Depreciation Schedule,plán odpisy
apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Adresy predajných partnerov a kontakty
DocType: Bank Reconciliation Detail,Against Account,Proti účet
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,Half Day Date should be between From Date and To Date,Half Day Date by mala byť v rozmedzí od dátumu a do dnešného dňa
DocType: Maintenance Schedule Detail,Actual Date,Skutečné datum
DocType: Item,Has Batch No,Má číslo šarže
apps/erpnext/erpnext/public/js/utils.js +96,Annual Billing: {0},Ročný Billing: {0}
apps/erpnext/erpnext/config/accounts.py +202,Goods and Services Tax (GST India),Daň z tovarov a služieb (GST India)
DocType: Delivery Note,Excise Page Number,Spotřební Číslo stránky
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +157,"Company, From Date and To Date is mandatory","Firma, Dátum od a do dnešného dňa je povinná"
DocType: Asset,Purchase Date,Dátum nákupu
DocType: Employee,Personal Details,Osobné údaje
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +192,Please set 'Asset Depreciation Cost Center' in Company {0},Prosím nastavte &quot;odpisy majetku nákladové stredisko&quot; vo firme {0}
,Maintenance Schedules,Plány údržby
DocType: Task,Actual End Date (via Time Sheet),Skutočný dátum ukončenia (cez Time Sheet)
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370,Amount {0} {1} against {2} {3},Množstvo {0} {1} na {2} {3}
,Quotation Trends,Vývoje ponúk
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +159,Item Group not mentioned in item master for item {0},Položka Group není uvedeno v položce mistra na položku {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +356,Debit To account must be a Receivable account,"Debetní Chcete-li v úvahu, musí být pohledávka účet"
DocType: Shipping Rule Condition,Shipping Amount,Prepravovaná čiastka
DocType: Supplier Scorecard Period,Period Score,Skóre obdobia
apps/erpnext/erpnext/public/js/setup_wizard.js +256,Add Customers,Pridať zákazníkov
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Čeká Částka
DocType: Purchase Invoice Item,Conversion Factor,Konverzní faktor
DocType: Purchase Order,Delivered,Dodává
,Vehicle Expenses,Náklady pre autá
DocType: Serial No,Invoice Details,Podrobnosti faktúry
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +155,Expected value after useful life must be greater than or equal to {0},"Očakávané hodnoty po celú dobu životnosti, musí byť väčšia ako alebo rovná {0}"
DocType: Purchase Invoice,SEZ,SEZ
DocType: Purchase Receipt,Vehicle Number,Číslo vozidla
DocType: Purchase Invoice,The date on which recurring invoice will be stop,"Dátum, kedy bude opakujúca sa faktúra zastavená"
DocType: Employee Loan,Loan Amount,Výška pôžičky
DocType: Program Enrollment,Self-Driving Vehicle,Samohybné vozidlo
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Hodnota karty dodávateľa je stála
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +424,Row {0}: Bill of Materials not found for the Item {1},Riadok {0}: Nomenklatúra nebol nájdený pre výtlačku {1}
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Celkové pridelené listy {0} nemôže byť nižšia ako už schválených listy {1} pre obdobie
DocType: Journal Entry,Accounts Receivable,Pohledávky
,Supplier-Wise Sales Analytics,Dodavatel-Wise Prodej Analytics
apps/erpnext/erpnext/schools/doctype/fees/fees.js +41,Enter Paid Amount,Vstup do zaplatená suma
DocType: Salary Structure,Select employees for current Salary Structure,Zvoliť zamestnancom za súčasného mzdovú štruktúru
DocType: Sales Invoice,Company Address Name,Názov adresy spoločnosti
DocType: Production Order,Use Multi-Level BOM,Použijte Multi-Level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Zahrnout odsouhlasené zápisy
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Rodičovský kurz (nechajte prázdne, ak toto nie je súčasťou materského kurzu)"
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Rodičovský kurz (nechajte prázdne, ak toto nie je súčasťou materského kurzu)"
DocType: Leave Control Panel,Leave blank if considered for all employee types,Nechajte prázdne ak má platiť pre všetky typy zamestnancov
DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuovat poplatků na základě
apps/erpnext/erpnext/hooks.py +128,Timesheets,Timesheets
DocType: HR Settings,HR Settings,Nastavení HR
DocType: Salary Slip,net pay info,Čistá mzda info
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +111,Expense Claim is pending approval. Only the Expense Approver can update status.,Úhrada výdajů čeká na schválení. Pouze schalovatel výdajů může aktualizovat stav.
DocType: Email Digest,New Expenses,nové výdavky
DocType: Purchase Invoice,Additional Discount Amount,Dodatočná zľava Suma
apps/erpnext/erpnext/controllers/accounts_controller.py +544,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Riadok # {0}: Množstvo musí byť 1, keď je položka investičného majetku. Prosím použiť samostatný riadok pre viacnásobné Mn."
DocType: Leave Block List Allow,Leave Block List Allow,Nechte Block List Povolit
apps/erpnext/erpnext/setup/doctype/company/company.py +289,Abbr can not be blank or space,Skrátená nemôže byť prázdne alebo priestor
apps/erpnext/erpnext/accounts/doctype/account/account.js +62,Group to Non-Group,Skupina na Non-Group
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,Sportovní
DocType: Loan Type,Loan Name,pôžička Name
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Celkem Aktuální
DocType: Student Siblings,Student Siblings,študentské Súrodenci
apps/erpnext/erpnext/public/js/setup_wizard.js +310,Unit,Jednotka
apps/erpnext/erpnext/stock/get_item_details.py +141,Please specify Company,"Uveďte prosím, firmu"
,Customer Acquisition and Loyalty,Zákazník Akvizice a loajality
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,"Sklad, kde se udržují zásoby odmítnutých položek"
DocType: Production Order,Skip Material Transfer,Preskočiť prenos materiálu
DocType: Production Order,Skip Material Transfer,Preskočiť prenos materiálu
apps/erpnext/erpnext/setup/utils.py +97,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Nepodarilo sa nájsť kurz {0} až {1} pre kľúčový dátum {2}. Ručne vytvorte záznam o menovej karte
DocType: POS Profile,Price List,Cenník
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,"{0} je teraz predvolený Fiškálny rok. Prosím aktualizujte svoj prehliadač, aby sa prejavili zmeny."
apps/erpnext/erpnext/projects/doctype/task/task.js +37,Expense Claims,Nákladové Pohľadávky
DocType: Issue,Support,Podpora
,BOM Search,BOM Search
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +189,Closing (Opening + Totals),Uzavretie (Otvorenie + súčty)
DocType: Vehicle,Fuel Type,Druh paliva
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,"Uveďte prosím měnu, ve společnosti"
DocType: Workstation,Wages per hour,Mzda za hodinu
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Sklad bilance v dávce {0} se zhorší {1} k bodu {2} ve skladu {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Nasledujúci materiál žiadosti boli automaticky zvýšená na základe úrovni re-poradie položky
DocType: Email Digest,Pending Sales Orders,Čaká Predajné objednávky
apps/erpnext/erpnext/controllers/accounts_controller.py +292,Account {0} is invalid. Account Currency must be {1},Účet {0} je neplatná. Mena účtu musí byť {1}
apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},UOM Konverzní faktor je nutné v řadě {0}
DocType: Production Plan Item,material_request_item,material_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1032,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Riadok # {0}: Reference Document Type musí byť jedným zo zákazky odberateľa, predajné faktúry alebo Journal Entry"
DocType: Salary Component,Deduction,Dedukce
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Riadok {0}: From Time a na čas je povinná.
DocType: Stock Reconciliation Item,Amount Difference,vyššie Rozdiel
apps/erpnext/erpnext/stock/get_item_details.py +297,Item Price added for {0} in Price List {1},Položka Cena pridaný pre {0} v Cenníku {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,"Prosím, zadajte ID zamestnanca z tohto predaja osoby"
DocType: Territory,Classification of Customers by region,Rozdělení zákazníků podle krajů
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +57,Difference Amount must be zero,Rozdiel Suma musí byť nula
DocType: Project,Gross Margin,Hrubá marža
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +53,Please enter Production Item first,"Prosím, zadejte první výrobní položku"
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Vypočítaná výpis z bankového účtu zostatok
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,zakázané uživatelské
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +764,Quotation,Ponuka
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +957,Cannot set a received RFQ to No Quote,Nie je možné nastaviť prijatú RFQ na žiadnu ponuku
DocType: Quotation,QTN-,QTN-
DocType: Salary Slip,Total Deduction,Celkem Odpočet
,Production Analytics,Analýza výroby
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +190,Cost Updated,Náklady Aktualizované
DocType: Employee,Date of Birth,Datum narození
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,Bod {0} již byla vrácena
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiškálny rok ** predstavuje finančný rok. Všetky účtovné záznamy a ďalšie významné transakcie sú sledované pod ** Fiškálny rok **.
DocType: Opportunity,Customer / Lead Address,Adresa zákazníka/obchodnej iniciatívy
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Nastavenie tabuľky dodávateľov
apps/erpnext/erpnext/stock/doctype/item/item.py +208,Warning: Invalid SSL certificate on attachment {0},Varovanie: Neplatný certifikát SSL na prílohu {0}
DocType: Student Admission,Eligibility,spôsobilosť
apps/erpnext/erpnext/utilities/activation.py +62,"Leads help you get business, add all your contacts and more as your leads","Obchodné iniciatívy vám pomôžu získať zákazku, zaevidovať všetky vaše kontakty"
DocType: Production Order Operation,Actual Operation Time,Aktuální Provozní doba
DocType: Authorization Rule,Applicable To (User),Vztahující se na (Uživatel)
DocType: Purchase Taxes and Charges,Deduct,Odečíst
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +199,Job Description,Popis Práca
DocType: Student Applicant,Applied,aplikovaný
DocType: Sales Invoice Item,Qty as per Stock UOM,Množstvo podľa skladovej MJ
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Meno Guardian2
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Špeciálne znaky okrem ""-"". """", ""#"", a ""/"" nie sú povolené v číselnej rade"
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Majte prehľad o predajných kampaniach. Majte prehľad o Iniciatívach, ponukách, objednávkach z kampane, aby ste zistili, návratnosť investície."
DocType: Expense Claim,Approver,Schvalovatel
,SO Qty,Množstvo na PO
DocType: Guardian,Work Address,pracovná adresa
DocType: Appraisal,Calculate Total Score,Vypočítať celkové skóre
DocType: Request for Quotation,Manufacturing Manager,Výrobný riaditeľ
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Pořadové číslo {0} je v záruce aľ {1}
apps/erpnext/erpnext/config/stock.py +158,Split Delivery Note into packages.,Rozdělit dodací list do balíčků.
apps/erpnext/erpnext/hooks.py +94,Shipments,Zásielky
DocType: Payment Entry,Total Allocated Amount (Company Currency),Celková alokovaná suma (Company mena)
DocType: Purchase Order Item,To be delivered to customer,Ak chcete byť doručený zákazníkovi
DocType: BOM,Scrap Material Cost,Šrot Material Cost
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,"Poradové číslo {0} nepatrí do skladu,"
DocType: Purchase Invoice,In Words (Company Currency),Slovy (měna společnosti)
DocType: Asset,Supplier,Dodávateľ
DocType: C-Form,Quarter,Čtvrtletí
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Různé výdaje
DocType: Global Defaults,Default Company,Výchozí Company
apps/erpnext/erpnext/controllers/stock_controller.py +227,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Náklady nebo Rozdíl účet je povinné k bodu {0} jako budou mít dopad na celkovou hodnotu zásob
DocType: Payment Request,PR,PR
DocType: Cheque Print Template,Bank Name,Názov banky
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +29,-Above,-Nad
DocType: Employee Loan,Employee Loan Account,Úverový účet zamestnanca
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 nebude odoslaný neaktívnym používateľom
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Počet interakcií
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Počet interakcií
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Vyberte spoločnost ...
DocType: Leave Control Panel,Leave blank if considered for all departments,Nechajte prázdne ak má platiť pre všetky oddelenia
apps/erpnext/erpnext/config/hr.py +219,"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 +422,{0} is mandatory for Item {1},{0} je povinná k položke {1}
DocType: Process Payroll,Fortnightly,dvojtýždňové
DocType: Currency Exchange,From Currency,Od Měny
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Prosím, vyberte alokovaná částka, typ faktury a číslo faktury v aspoň jedné řadě"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +125,Cost of New Purchase,Náklady na nový nákup
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Prodejní objednávky potřebný k bodu {0}
DocType: Purchase Invoice Item,Rate (Company Currency),Cena (Měna Společnosti)
DocType: Student Guardian,Others,Ostatní
DocType: Payment Entry,Unallocated Amount,nepridelené Suma
apps/erpnext/erpnext/templates/includes/product_page.js +71,Cannot find a matching Item. Please select some other value for {0}.,Nemožno nájsť zodpovedajúce položku. Vyberte nejakú inú hodnotu pre {0}.
DocType: POS Profile,Taxes and Charges,Daně a poplatky
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Produkt nebo služba, která se Nakupuje, Prodává nebo Skladuje."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Žiadne ďalšie aktualizácie
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +154,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,"Nelze vybrat druh náboje jako ""On předchozí řady Částka"" nebo ""On předchozí řady Celkem"" pro první řadu"
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Toto pokrýva všetky výsledkové karty viazané na toto nastavenie
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Dieťa Položka by nemala byť produkt Bundle. Odstráňte položku `{0}` a uložiť
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Bankovníctvo
apps/erpnext/erpnext/utilities/activation.py +106,Add Timesheets,Pridať Timesheets
DocType: Vehicle Service,Service Item,servis Položka
DocType: Bank Guarantee,Bank Guarantee,Banková záruka
DocType: Bank Guarantee,Bank Guarantee,Banková záruka
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,"Prosím, klikněte na ""Generovat Schedule"", aby se plán"
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +56,There were errors while deleting following schedules:,Došlo k chybám počas odstraňovania tejto schémy:
DocType: Bin,Ordered Quantity,Objednané množstvo
apps/erpnext/erpnext/public/js/setup_wizard.js +100,"e.g. ""Build tools for builders""","napríklad ""Nástroje pre stavbárov """
DocType: Grading Scale,Grading Scale Intervals,Triedenie dielikov
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Účtovné Vstup pre {2} môžu vykonávať len v mene: {3}
DocType: Production Order,In Process,V procesu
DocType: Authorization Rule,Itemwise Discount,Itemwise Sleva
apps/erpnext/erpnext/config/accounts.py +69,Tree of financial accounts.,Strom finančných účtov.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} proti Predajnej Objednávke {1}
DocType: Account,Fixed Asset,Základní Jmění
apps/erpnext/erpnext/config/stock.py +315,Serialized Inventory,Serialized Zásoby
DocType: Employee Loan,Account Info,Informácie o účte
DocType: Activity Type,Default Billing Rate,Predvolené fakturácia Rate
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Vytvorené študentské skupiny.
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Vytvorené študentské skupiny.
DocType: Sales Invoice,Total Billing Amount,Celková suma fakturácie
apps/erpnext/erpnext/hr/doctype/daily_work_summary_settings/daily_work_summary_settings.py +17,There must be a default incoming Email Account enabled for this to work. Please setup a default incoming Email Account (POP/IMAP) and try again.,Musí existovať predvolený prichádzajúce e-mailové konto povolený pre túto prácu. Prosím nastaviť predvolené prichádzajúce e-mailové konto (POP / IMAP) a skúste to znova.
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +80,Receivable Account,Pohledávky účtu
apps/erpnext/erpnext/controllers/accounts_controller.py +566,Row #{0}: Asset {1} is already {2},Riadok # {0}: Asset {1} je už {2}
DocType: Quotation Item,Stock Balance,Stav zásob
apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Predajné objednávky na platby
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +92,CEO,CEO
DocType: Purchase Invoice,With Payment of Tax,S platbou dane
DocType: Expense Claim Detail,Expense Claim Detail,Detail úhrady výdajů
DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLIKÁT PRE DODÁVATEĽA
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +859,Please select correct account,"Prosím, vyberte správny účet"
DocType: Item,Weight UOM,Hmotnostná MJ
DocType: Salary Structure Employee,Salary Structure Employee,Plat štruktúra zamestnancov
DocType: Employee,Blood Group,Krevní Skupina
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +961,Pending,Čakajúce
DocType: Course,Course Name,Názov kurzu
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,"Uživatelé, kteří si vyhoví žádosti konkrétního zaměstnance volno"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Kancelářské Vybavení
DocType: Purchase Invoice Item,Qty,Množství
DocType: Fiscal Year,Companies,Společnosti
DocType: Supplier Scorecard,Scoring Setup,Nastavenie bodovania
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +24,Electronics,Elektronika
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Zvýšit Materiál vyžádání při stock dosáhne úrovně re-order
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +67,Full-time,Na plný úvazek
DocType: Salary Structure,Employees,zamestnanci
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.","Ak ste vytvorili štandardné šablónu v predaji daní a poplatkov šablóny, vyberte jednu a kliknite na tlačidlo nižšie."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Základná suma (Company mena)
DocType: Student,Guardians,Guardians
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,"Ceny sa nebudú zobrazovať, pokiaľ Cenník nie je nastavený"
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +28,Please specify a country for this Shipping Rule or check Worldwide Shipping,"Uveďte prosím krajinu, k tomuto Shipping pravidlá alebo skontrolovať Celosvetová doprava"
DocType: Stock Entry,Total Incoming Value,Celková hodnota Příchozí
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +350,Debit To is required,Debetné K je vyžadované
apps/erpnext/erpnext/utilities/activation.py +107,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets pomôže udržať prehľad o času, nákladov a účtovania pre aktivít hotový svojho tímu"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Nákupní Ceník
apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Šablóny premenných ukazovateľa skóre dodávateľa.
DocType: Offer Letter Term,Offer Term,Ponuka Term
DocType: Quality Inspection,Quality Manager,Manažér kvality
DocType: Job Applicant,Job Opening,Job Zahájení
DocType: Payment Reconciliation,Payment Reconciliation,Platba Odsouhlasení
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,"Prosím, vyberte incharge jméno osoby"
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +51,Technology,Technologie
apps/erpnext/erpnext/public/js/utils.js +98,Total Unpaid: {0},Celkové nezaplatené: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Website Operation
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Ponuka Letter
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Generování materiálu Požadavky (MRP) a výrobní zakázky.
DocType: Supplier Scorecard,Supplier Score,Skóre dodávateľa
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +76,Total Invoiced Amt,Celkové fakturované Amt
DocType: Supplier,Warn RFQs,Upozornenie na RFQ
DocType: BOM,Conversion Rate,Konverzný kurz
apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Hľadať produkt
DocType: Timesheet Detail,To Time,Chcete-li čas
DocType: Authorization Rule,Approving Role (above authorized value),Schválenie role (nad oprávnenej hodnoty)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +114,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 +317,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 +148,"For {0}, only debit accounts can be linked against another credit entry","Pro {0}, tak debetní účty mohou být spojeny proti jinému připsání"
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Cenník {0} je vypnutý
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Riadok {0}: Dokončené Množstvo nemôže byť viac ako {1} pre prevádzku {2}
DocType: Manufacturing Settings,Allow Overtime,Povoliť Nadčasy
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry",Serializovaná položka {0} sa nedá aktualizovať pomocou zmiernenia skladových položiek
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry",Serializovaná položka {0} sa nedá aktualizovať pomocou zmiernenia skladových položiek
DocType: Training Event Employee,Training Event Employee,Vzdelávanie zamestnancov Event
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Sériové čísla požadované pre položku {1}. Poskytli ste {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Aktuálne ocenenie Rate
DocType: Item,Customer Item Codes,Zákazník Položka Kódy
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Exchange zisk / strata
DocType: Opportunity,Lost Reason,Ztracené Důvod
apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Nová adresa
DocType: Quality Inspection,Sample Size,Veľkosť vzorky
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,"Prosím, zadajte prevzatia dokumentu"
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,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/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,"Ďalšie nákladové strediská môžu byť vyrobené v rámci skupiny, ale položky môžu byť vykonané proti non-skupín"
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Uživatelé a oprávnění
DocType: Vehicle Log,VLOG.,Vlog.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +935,Production Orders Created: {0},Výrobné zákazky Vytvorené: {0}
DocType: Branch,Branch,Větev
DocType: Guardian,Mobile Number,Telefónne číslo
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Tisk a identita
DocType: Company,Total Monthly Sales,Celkový mesačný predaj
DocType: Bin,Actual Quantity,Skutočné Množstvo
DocType: Shipping Rule,example: Next Day Shipping,Příklad: Next Day Shipping
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,Pořadové číslo {0} nebyl nalezen
DocType: Program Enrollment,Student Batch,študent Batch
apps/erpnext/erpnext/utilities/activation.py +117,Make Student,Vytvoriť študenta
DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
apps/erpnext/erpnext/projects/doctype/project/project.py +198,You have been invited to collaborate on the project: {0},Boli ste pozvaní k spolupráci na projekte: {0}
DocType: Leave Block List Date,Block Date,Block Datum
DocType: Purchase Receipt,Supplier Delivery Note,Dodacie oznámenie dodávateľa
apps/erpnext/erpnext/templates/generators/student_admission.html +23,Apply Now,Nainštalovať teraz
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Aktuálny počet {0} / Čakajúci počet {1}
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Aktuálny počet {0} / Čakajúci počet {1}
DocType: Purchase Invoice,E-commerce GSTIN,Elektronický obchod GSTIN
DocType: Sales Order,Not Delivered,Nedodané
,Bank Clearance Summary,Súhrn bankového zúčtovania
apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Vytvářet a spravovat denní, týdenní a měsíční e-mailové digest."
DocType: Appraisal Goal,Appraisal Goal,Posouzení Goal
DocType: Stock Reconciliation Item,Current Amount,Aktuálna výška
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,budovy
DocType: Fee Structure,Fee Structure,štruktúra poplatkov
DocType: Timesheet Detail,Costing Amount,Kalkulácie Čiastka
DocType: Student Admission,Application Fee,Poplatok za prihlášku
DocType: Process Payroll,Submit Salary Slip,Odeslat výplatní pásce
apps/erpnext/erpnext/controllers/selling_controller.py +162,Maxiumm discount for Item {0} is {1}%,Maxiumm sleva na položky {0} {1}%
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Dovoz hromadnú
DocType: Sales Partner,Address & Contacts,Adresa a kontakty
DocType: SMS Log,Sender Name,Meno odosielateľa
DocType: POS Profile,[Select],[Vybrať]
DocType: SMS Log,Sent To,Odoslané na
DocType: Payment Request,Make Sales Invoice,Vytvoriť faktúru
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,programy
apps/erpnext/erpnext/crm/doctype/lead/lead.py +50,Next Contact Date cannot be in the past,Nasledujúce Kontakt dátum nemôže byť v minulosti
DocType: Company,For Reference Only.,Pouze orientační.
apps/erpnext/erpnext/accounts/page/pos/pos.js +2468,Select Batch No,Vyberte položku šarže
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},Neplatný {0}: {1}
DocType: Purchase Invoice,PINV-RET-,PInv-RET-
DocType: Sales Invoice Advance,Advance Amount,Záloha ve výši
DocType: Manufacturing Settings,Capacity Planning,Plánovanie kapacít
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,"""Dátum 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é pracovisko
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Nastaviť ako Zatvorené
apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Barcode {0},No Položka s čárovým kódem {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Případ č nemůže být 0
DocType: Item,Show a slideshow at the top of the page,Ukazují prezentaci v horní části stránky
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +492,Boms,kusovníky
apps/erpnext/erpnext/stock/doctype/item/item.py +137,Stores,Obchody
DocType: Project Type,Projects Manager,Správce projektů
DocType: Serial No,Delivery Time,Dodací lhůta
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Stárnutí dle
DocType: Item,End of Life,Konec životnosti
apps/erpnext/erpnext/demo/setup/setup_data.py +328,Travel,Cestování
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +180,No active or default Salary Structure found for employee {0} for the given dates,Žiadny aktívny alebo implicitné Plat Štruktúra nájdených pre zamestnancov {0} pre dané termíny
DocType: Leave Block List,Allow Users,Povolit uživatele
DocType: Purchase Order,Customer Mobile No,Zákazník Mobile Žiadne
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,Nástroj na premenovanie
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +37,Update Cost,Aktualizace Cost
DocType: Item Reorder,Item Reorder,Položka Reorder
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +446,Show Salary Slip,Show výplatnej páske
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +814,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."
apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Tento dokument je nad hranicou {0} {1} pre položku {4}. Robíte si iný {3} proti rovnakej {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js +982,Please set recurring after saving,Prosím nastavte opakovanie po uložení
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +755,Select change amount account,Vybrať zmena výšky účet
DocType: Purchase Invoice,Price List Currency,Mena cenníka
DocType: Naming Series,User must always select,Uživatel musí vždy vybrat
DocType: Stock Settings,Allow Negative Stock,Povolit Negativní Sklad
DocType: Installation Note,Installation Note,Poznámka k instalaci
apps/erpnext/erpnext/public/js/setup_wizard.js +237,Add Taxes,Pridajte dane
DocType: Topic,Topic,téma
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Peňažný tok z finančnej
DocType: Budget Account,Budget Account,rozpočet účtu
DocType: Quality Inspection,Verified By,Verified By
apps/erpnext/erpnext/setup/doctype/company/company.py +70,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Nelze změnit výchozí měně společnosti, protože tam jsou stávající transakce. Transakce musí být zrušena, aby změnit výchozí měnu."
DocType: Grading Scale Interval,Grade Description,grade Popis
DocType: Stock Entry,Purchase Receipt No,Číslo příjmky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Earnest Money
DocType: Process Payroll,Create Salary Slip,Vytvořit výplatní pásce
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,sledovateľnosť
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Zdrojem finančních prostředků (závazků)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +381,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Množství v řadě {0} ({1}), musí být stejné jako množství vyrobené {2}"
DocType: Supplier Scorecard Scoring Standing,Employee,Zamestnanec
DocType: Company,Sales Monthly History,Mesačná história predaja
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +183,Select Batch,Vyberte možnosť Dávka
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} je úplne fakturované
DocType: Training Event,End Time,End Time
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Aktívne Štruktúra Plat {0} nájdené pre zamestnancov {1} pre uvedené termíny
DocType: Payment Entry,Payment Deductions or Loss,Platobné zrážky alebo strata
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Standardní smluvní podmínky pro prodej nebo koupi.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Seskupit podle Poukazu
apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,predajné Pipeline
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +216,Please set default account in Salary Component {0},Prosím nastaviť predvolený účet platu Component {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Povinné On
DocType: Rename Tool,File to Rename,Súbor premenovať
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +204,Please select BOM for Item in Row {0},"Prosím, vyberte BOM pre položku v riadku {0}"
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Účet {0} sa nezhoduje so spoločnosťou {1} v režime účtov: {2}
apps/erpnext/erpnext/controllers/buying_controller.py +268,Specified BOM {0} does not exist for Item {1},Stanovená BOM {0} neexistuje k bodu {1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +221,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Plán údržby {0} musí být zrušena před zrušením této prodejní objednávky
DocType: Notification Control,Expense Claim Approved,Uhrazení výdajů schváleno
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +319,Salary Slip of employee {0} already created for this period,Výplatnej páske zamestnanca {0} už vytvorili pre toto obdobie
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +124,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,Je potrebná predajná objednávka
DocType: Purchase Invoice,Credit To,Kredit:
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Aktívne Iniciatívy / Zákazníci
DocType: Employee Education,Post Graduate,Postgraduální
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Plán údržby Detail
DocType: Supplier Scorecard,Warn for new Purchase Orders,Upozornenie na nové nákupné objednávky
DocType: Quality Inspection Reading,Reading 9,Čtení 9
DocType: Supplier,Is Frozen,Je Frozen
apps/erpnext/erpnext/stock/utils.py +217,Group node warehouse is not allowed to select for transactions,Uzol skupina sklad nie je dovolené vybrať pre transakcie
DocType: Buying Settings,Buying Settings,Nastavenie nákupu
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM Ne pro hotový dobré položce
DocType: Upload Attendance,Attendance To Date,Účast na data
DocType: Request for Quotation Supplier,No Quote,Žiadna citácia
DocType: Warranty Claim,Raised By,Vznesené
DocType: Payment Gateway Account,Payment Account,Platební účet
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +874,Please specify Company to proceed,Uveďte prosím společnost pokračovat
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Čistá zmena objemu pohľadávok
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +57,Compensatory Off,Vyrovnávací Off
DocType: Offer Letter,Accepted,Přijato
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,organizácie
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,organizácie
DocType: BOM Update Tool,BOM Update Tool,Nástroj na aktualizáciu kusovníka
DocType: SG Creation Tool Course,Student Group Name,Meno Študent Group
apps/erpnext/erpnext/setup/doctype/company/company.js +52,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.,"Uistite sa, že naozaj chcete vymazať všetky transakcie pre túto spoločnosť. Vaše kmeňové dáta zostanú, ako to je. Túto akciu nie je možné vrátiť späť."
DocType: Room,Room Number,Číslo izby
apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Neplatná referencie {0} {1}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +167,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},"{0} ({1}) nemôže byť väčšie, ako plánované množstvo ({2}), vo Výrobnej Objednávke {3}"
DocType: Shipping Rule,Shipping Rule Label,Přepravní Pravidlo Label
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,user Forum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +287,Raw Materials cannot be blank.,Suroviny nemůže být prázdný.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +486,"Could not update stock, invoice contains drop shipping item.","Nie je možné aktualizovať zásob, faktúra obsahuje pokles lodnej dopravy tovaru."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +484,Quick Journal Entry,Rýchly vstup Journal
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +169,You can not change rate if BOM mentioned agianst any item,"Nemůžete změnit sazbu, kdyby BOM zmínil agianst libovolné položky"
DocType: Employee,Previous Work Experience,Předchozí pracovní zkušenosti
DocType: Stock Entry,For Quantity,Pre Množstvo
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +209,Please enter Planned Qty for Item {0} at row {1},"Prosím, zadejte Plánované Množství k bodu {0} na řádku {1}"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} nie je odoslané
apps/erpnext/erpnext/config/stock.py +27,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.
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} musí byť negatívny vo vratnom dokumente
,Minutes to First Response for Issues,Zápisy do prvej reakcie na otázky
DocType: Purchase Invoice,Terms and Conditions1,Podmínky a podmínek1
apps/erpnext/erpnext/public/js/setup_wizard.js +91,The name of the institute for which you are setting up this system.,Názov inštitútu pre ktorý nastavujete tento systém.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Účetní záznam zmrazeny až do tohoto data, nikdo nemůže dělat / upravit položku kromě role uvedeno níže."
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,"Prosím, uložit dokument před generováním plán údržby"
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Posledná cena bola aktualizovaná vo všetkých kusovníkoch
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Stav projektu
DocType: UOM,Check this to disallow fractions. (for Nos),"Zkontrolujte, zda to zakázat frakce. (U č)"
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +428,The following Production Orders were created:,Nasledujúce Výrobné zákazky boli vytvorené:
DocType: Student Admission,Naming Series (for Student Applicant),Pomenovanie Series (pre študentské prihlasovateľ)
DocType: Delivery Note,Transporter Name,Přepravce Název
DocType: Authorization Rule,Authorized Value,Autorizovaný Hodnota
DocType: BOM,Show Operations,ukázať Operations
,Minutes to First Response for Opportunity,Zápisy do prvej reakcie na príležitosť
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Celkem Absent
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +793,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 +189,Unit of Measure,Merná jednotka
DocType: Fiscal Year,Year End Date,Dátum konca roka
DocType: Task Depends On,Task Depends On,Úloha je závislá na
DocType: Supplier Quotation,Opportunity,Příležitost
,Completed Production Orders,Dokončené Výrobní zakázky
DocType: Operation,Default Workstation,Výchozí Workstation
DocType: Notification Control,Expense Claim Approved Message,Správa o schválení úhrady výdavkov
DocType: Payment Entry,Deductions or Loss,Odpočty alebo strata
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} je uzavretý
DocType: Email Digest,How frequently?,Jak často?
DocType: Purchase Receipt,Get Current Stock,Získať aktuálny stav
apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Strom Bill materiálov
DocType: Student,Joining Date,spájanie Dátum
,Employees working on a holiday,Zamestnanci pracujúci na dovolenku
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,mark Present
DocType: Project,% Complete Method,Dokončené% Method
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},Datum zahájení údržby nemůže být před datem dodání pro pořadové číslo {0}
DocType: Production Order,Actual End Date,Skutečné datum ukončení
DocType: BOM,Operating Cost (Company Currency),Prevádzkové náklady (Company mena)
DocType: Purchase Invoice,PINV-,PINV-
DocType: Authorization Rule,Applicable To (Role),Vztahující se na (Role)
DocType: BOM Update Tool,Replace BOM,Nahraďte kusovník
DocType: Stock Entry,Purpose,Účel
DocType: Company,Fixed Asset Depreciation Settings,Nastavenie odpisovania dlhodobého majetku
DocType: Item,Will also apply for variants unless overrridden,"Bude platiť aj pre varianty, pokiaľ nebude prepísané"
DocType: Purchase Invoice,Advances,Zálohy
DocType: Production Order,Manufacture against Material Request,Výroba proti Materiál Request
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Hodnotiaca skupina:
DocType: Item Reorder,Request for,Žiadosť o
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Schválení Uživatel nemůže být stejná jako uživatel pravidlo se vztahuje na
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Základná sadzba (podľa skladovej MJ)
DocType: SMS Log,No of Requested SMS,Počet žádaným SMS
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +243,Leave Without Pay does not match with approved Leave Application records,Nechať bez nároku na odmenu nesúhlasí so schválenými záznamov nechať aplikáciu
DocType: Campaign,Campaign-.####,Kampaň-.####
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Ďalšie kroky
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +769,Please supply the specified items at the best possible rates,Prosím dodávať uvedené položky na najlepšie možné ceny
DocType: Selling Settings,Auto close Opportunity after 15 days,Auto zavrieť Opportunity po 15 dňoch
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +74,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Objednávky nie sú povolené {0} kvôli postaveniu skóre {1}.
apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,koniec roka
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Olovo%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Olovo%
apps/erpnext/erpnext/hr/doctype/employee/employee.py +119,Contract End Date must be greater than Date of Joining,Smlouva Datum ukončení musí být větší než Datum spojování
DocType: Delivery Note,DN-,DN-
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,"Distributor / dealer / jednatel / partner / prodejce, který prodává produkty společnosti za provizi."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} proti Objednávke {1}
DocType: Task,Actual Start Date (via Time Sheet),Skutočný dátum začatia (cez Časový rozvrh)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Toto je príklad webovej stránky automaticky generovanej z ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Stárnutí Rozsah 1
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: Homepage,Homepage,Úvodné
DocType: Purchase Receipt Item,Recd Quantity,Recd Množství
apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +57,Fee Records Created - {0},Fee Records Vytvoril - {0}
DocType: Asset Category Account,Asset Category Account,Asset Kategórie Account
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +117,Cannot produce more Item {0} than Sales Order quantity {1},Nie je možné vyrobiť viac Položiek {0} ako je množstvo na predajnej objednávke {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Sklad Entry {0} nie je predložená
DocType: Payment Reconciliation,Bank / Cash Account,Bankový / Peňažný účet
apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Next Contact By cannot be same as the Lead Email Address,Nasledujúce Kontakt Tým nemôže byť rovnaký ako hlavný e-mailovú adresu
DocType: Tax Rule,Billing City,Fakturačné mesto
DocType: Asset,Manual,Manuálny
DocType: Salary Component Account,Salary Component Account,Účet plat Component
DocType: Global Defaults,Hide Currency Symbol,Skrýt symbol měny
apps/erpnext/erpnext/config/accounts.py +327,"e.g. Bank, Cash, Credit Card","napríkklad banka, hotovosť, kreditné karty"
DocType: Lead Source,Source Name,Názov zdroja
DocType: Journal Entry,Credit Note,Dobropis
DocType: Warranty Claim,Service Address,Servisní adresy
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Nábytok a svietidlá
DocType: Item,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: Student Applicant,Application Date,aplikácie Dátum
DocType: Salary Detail,Amount based on formula,Suma podľa vzorca
DocType: Purchase Invoice,Currency and Price List,Cenník a mena
DocType: Opportunity,Customer / Lead Name,Zákazník / Iniciatíva Meno
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Výprodej Datum není uvedeno
apps/erpnext/erpnext/config/manufacturing.py +7,Production,Výroba
DocType: Guardian,Occupation,povolania
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,"Row {0}: datum zahájení, musí být před koncem roku Datum"
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Total (ks)
DocType: Sales Invoice,This Document,tento dokument
DocType: Installation Note Item,Installed Qty,Instalované množství
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +7,Training Result,tréning Výsledok
DocType: Purchase Invoice,Is Paid,sa vypláca
DocType: Salary Structure,Total Earning,Celkem Zisk
DocType: Purchase Receipt,Time at which materials were received,"Čas, kdy bylo přijato materiály"
DocType: Stock Ledger Entry,Outgoing Rate,Odchádzajúce Rate
apps/erpnext/erpnext/config/hr.py +224,Organization branch master.,Organizace větev master.
apps/erpnext/erpnext/controllers/accounts_controller.py +293, or ,alebo
DocType: Sales Order,Billing Status,Stav fakturácie
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Nahlásiť problém
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Utility Náklady
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90 Nad
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +237,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Riadok # {0}: Journal Entry {1} nemá účet {2} alebo už uzavreté proti inému poukazu
DocType: Supplier Scorecard Criteria,Criteria Weight,Hmotnosť kritérií
DocType: Buying Settings,Default Buying Price List,Výchozí Nákup Ceník
DocType: Process Payroll,Salary Slip Based on Timesheet,Plat Slip na základe časového rozvrhu
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +113,No employee for the above selected criteria OR salary slip already created,Žiadny zamestnanec pre vyššie zvolených kritérií alebo výplatnej páske už vytvorili
DocType: Notification Control,Sales Order Message,Poznámka predajnej objednávky
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Nastavit jako výchozí hodnoty, jako je společnost, měna, aktuálním fiskálním roce, atd"
DocType: Payment Entry,Payment Type,Typ platby
apps/erpnext/erpnext/stock/doctype/batch/batch.py +130,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Vyberte položku Dávka pre položku {0}. Nie je možné nájsť jednu dávku, ktorá spĺňa túto požiadavku"
apps/erpnext/erpnext/stock/doctype/batch/batch.py +130,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,"Vyberte položku Dávka pre položku {0}. Nie je možné nájsť jednu dávku, ktorá spĺňa túto požiadavku"
DocType: Process Payroll,Select Employees,Vybrať Zamestnanci
DocType: Opportunity,Potential Sales Deal,Potenciální prodej
DocType: Payment Entry,Cheque/Reference Date,Šek / Referenčný dátum
DocType: Purchase Invoice,Total Taxes and Charges,Celkem Daně a poplatky
DocType: Employee,Emergency Contact,Kontakt v nouzi
DocType: Bank Reconciliation Detail,Payment Entry,platba Entry
DocType: Item,Quality Parameters,Parametry kvality
,sales-browser,Predajná-browser
apps/erpnext/erpnext/accounts/doctype/account/account.js +73,Ledger,Účtovná kniha
DocType: Target Detail,Target  Amount,Cílová částka
DocType: Shopping Cart Settings,Shopping Cart Settings,Nastavenie Nákupného košíka
DocType: Journal Entry,Accounting Entries,Účetní záznamy
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Duplicitní záznam. Zkontrolujte autorizační pravidlo {0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +29,Global POS Profile {0} already created for company {1},Global POS Profile {0} už vytvorili pre firmu {1}
DocType: Purchase Order,Ref SQ,Ref SQ
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,Príjem a musí byť predložený
DocType: Purchase Invoice Item,Received Qty,Přijaté Množství
DocType: Stock Entry Detail,Serial No / Batch,Sériové číslo / Dávka
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +320,Not Paid and Not Delivered,Nezaplatené a nedoručené
DocType: Product Bundle,Parent Item,Nadřazená položka
DocType: Account,Account Type,Typ účtu
DocType: Delivery Note,DN-RET-,DN-RET-
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Žiadne časové rozvrhy
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,Nechajte typ {0} nemožno vykonávať odovzdávané
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',"Plán údržby není generován pro všechny položky. Prosím, klikněte na ""Generovat Schedule"""
,To Produce,K výrobě
apps/erpnext/erpnext/config/hr.py +93,Payroll,Mzda
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +179,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pre riadok {0} v {1}. Ak chcete v rýchlosti položku sú {2}, riadky {3} musí byť tiež zahrnuté"
apps/erpnext/erpnext/utilities/activation.py +99,Make User,Vytvoriť používateľa
DocType: Packing Slip,Identification of the package for the delivery (for print),Identifikace balíčku pro dodávky (pro tisk)
DocType: Bin,Reserved Quantity,Vyhrazeno Množství
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Zadajte platnú e-mailovú adresu
DocType: Landed Cost Voucher,Purchase Receipt Items,Položky příjemky
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Prispôsobenie Formuláre
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +43,Arrear,nedoplatok
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Depreciation Amount during the period,Odpisy hodnoty v priebehu obdobia
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,Bezbariérový šablóna nesmie byť predvolenú šablónu
DocType: Account,Income Account,Účet příjmů
DocType: Payment Request,Amount in customer's currency,Čiastka v mene zákazníka
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +776,Delivery,Dodávka
DocType: Stock Reconciliation Item,Current Qty,Aktuálne Množstvo
DocType: BOM Item,"See ""Rate Of Materials Based On"" in Costing Section","Viz ""Hodnotit materiálů na bázi"" v kapitole Costing"
apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Predchádzajúce
DocType: Appraisal Goal,Key Responsibility Area,Key Odpovědnost Area
apps/erpnext/erpnext/utilities/activation.py +125,"Student Batches help you track attendance, assessments and fees for students","Študent Šarže pomôže sledovať dochádzku, hodnotenia a poplatky pre študentov"
DocType: Payment Entry,Total Allocated Amount,Celková alokovaná suma
apps/erpnext/erpnext/setup/doctype/company/company.py +150,Set default inventory account for perpetual inventory,Nastavte predvolený inventárny účet pre trvalý inventár
DocType: Item Reorder,Material Request Type,Materiál Typ požadavku
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +268,Accural Journal Entry for salaries from {0} to {1},Accural Journal vstup na platy z {0} až {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +803,"LocalStorage is full, did not save","Miestne úložisko je plné, nezachránil"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +85,Row {0}: UOM Conversion Factor is mandatory,Riadok {0}: Konverzný faktor MJ je povinný
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref
DocType: Budget,Cost Center,Nákladové středisko
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,Voucher #,Voucher #
DocType: Notification Control,Purchase Order Message,Poznámka k nákupnej objednávke
DocType: Tax Rule,Shipping Country,Krajina dodania
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Inkognito dane zákazníka z predajných transakcií
DocType: Upload Attendance,Upload HTML,Nahrát HTML
DocType: Employee,Relieving Date,Uvolnění Datum
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Ceny Pravidlo je vyrobena přepsat Ceník / definovat slevy procenta, na základě určitých kritérií."
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,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/setup_wizard/install_fixtures.py +103,Head of Marketing and Sales,Vedoucí marketingu a prodeje
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +41,Income Tax,Daň z příjmů
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Je-li zvolena Ceny pravidlo je určen pro ""Cena"", přepíše ceníku. Ceny Pravidlo cena je konečná cena, a proto by měla být použita žádná další sleva. Proto, v transakcích, jako odběratele, objednávky atd, bude stažen v oboru ""sazbou"", spíše než poli ""Ceník sazby""."
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Trasa vede od průmyslu typu.
DocType: Item Supplier,Item Supplier,Položka Dodavatel
apps/erpnext/erpnext/public/js/controllers/transaction.js +1083,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 +816,Please select a value for {0} quotation_to {1},Vyberte prosím hodnotu pro {0} quotation_to {1}
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Všetky adresy
DocType: Company,Stock Settings,Nastavenie Skladu
apps/erpnext/erpnext/accounts/doctype/account/account.py +199,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Spojenie je možné len vtedy, ak tieto vlastnosti sú rovnaké v oboch záznamoch. Je Group, Root Type, Company"
DocType: Vehicle,Electric,elektrický
DocType: Task,% Progress,% Progress
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Zisk / strata z aktív likvidácii
DocType: Training Event,Will send an email about the event to employees with status 'Open',"Pošle e-mail o tejto udalosti, aby zamestnanci so statusom &quot;otvorený&quot;"
DocType: Task,Depends on Tasks,Závisí na Úlohy
apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Správa zákazníků skupiny Tree.
DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Prílohy je možné zobraziť bez povolenia nákupného košíka
DocType: Supplier Quotation,SQTN-,SQTN-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Názov nového nákladového strediska
DocType: Leave Control Panel,Leave Control Panel,Nechte Ovládací panely
DocType: Project,Task Completion,úloha Dokončenie
apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,nie je na sklade
DocType: Appraisal,HR User,HR User
DocType: Purchase Invoice,Taxes and Charges Deducted,Daně a odečtené
apps/erpnext/erpnext/hooks.py +125,Issues,Problémy
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Stav musí být jedním z {0}
DocType: Sales Invoice,Debit To,Debetní K
DocType: 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
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +65,No salary slip found between {0} and {1},Č plat sklzu nájdený medzi {0} a {1}
,Pending SO Items For Purchase Request,"Do doby, než SO položky k nákupu Poptávka"
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +29,Student Admissions,študent Prijímacie
apps/erpnext/erpnext/accounts/party.py +353,{0} {1} is disabled,{0} {1} je zakázaný
DocType: Supplier,Billing Currency,Mena fakturácie
DocType: Sales Invoice,SINV-RET-,Sinv-RET-
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +169,Extra Large,Extra Veľké
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Celkom Listy
,Profit and Loss Statement,Výkaz ziskov a strát
DocType: Bank Reconciliation Detail,Cheque Number,Šek číslo
,Sales Browser,Prehliadač predaja
DocType: Journal Entry,Total Credit,Celkový Credit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Upozornenie: Ďalším {0} # {1} existuje proti akciovej vstupu {2}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +120,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/setup_wizard/install_fixtures.py +168,Large,Veľký
DocType: Homepage Featured Product,Homepage Featured Product,Úvodná Odporúčané tovar
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +209,All Assessment Groups,Všetky skupiny Assessment
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Nový sklad Name
apps/erpnext/erpnext/accounts/report/financial_statements.py +227,Total {0} ({1}),Celkom {0} ({1})
DocType: C-Form Invoice Detail,Territory,Území
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,"Prosím, uveďte počet požadovaných návštěv"
DocType: Stock Settings,Default Valuation Method,Výchozí metoda ocenění
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +26,Fee,poplatok
DocType: Vehicle Log,Fuel Qty,palivo Množstvo
DocType: Production Order Operation,Planned Start Time,Plánované Start Time
DocType: Course,Assessment,posúdenie
DocType: Payment Entry Reference,Allocated,Přidělené
apps/erpnext/erpnext/config/accounts.py +269,Close Balance Sheet and book Profit or Loss.,Zavřete Rozvahu a zapiš účetní zisk nebo ztrátu.
DocType: Student Applicant,Application Status,stav aplikácie
DocType: Fees,Fees,poplatky
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Zadejte Exchange Rate převést jednu měnu na jinou
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +158,Quotation {0} is cancelled,Ponuka {0} je zrušená
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Celková dlužná částka
DocType: Sales Partner,Targets,Cíle
DocType: Price List,Price List Master,Ceník Master
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,"Všechny prodejní transakce mohou být označeny proti více ** prodejcům **, takže si můžete nastavit a sledovat cíle."
,S.O. No.,SO Ne.
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +201,Please create Customer from Lead {0},Prosím vytvorte Zákazníka z Obchodnej iniciatívy {0}
DocType: Price List,Applicable for Countries,Pre krajiny
DocType: Supplier Scorecard Scoring Variable,Parameter Name,Názov parametra
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,"Nechajte len aplikácie, ktoré majú status, schválené &#39;i, Zamietnuté&#39; môžu byť predložené"
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Študent Názov skupiny je povinné v rade {0}
DocType: Homepage,Products to be shown on website homepage,"Produkty, ktoré majú byť uvedené na internetových stránkach domovskej"
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,"To je kořen skupiny zákazníků, a nelze upravovat."
DocType: Employee,AB-,AB-
DocType: POS Profile,Ignore Pricing Rule,Ignorovat Ceny pravidlo
DocType: Employee Education,Graduate,Absolvent
DocType: Leave Block List,Block Days,Blokové dny
DocType: Journal Entry,Excise Entry,Spotřební Entry
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +64,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Upozornenie: predajné objednávky {0} už existuje proti Zákazníka objednanie {1}
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
DocType: Purchase Invoice,Supplier Invoice Details,Detaily dodávateľskej faktúry
apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Náklady / Rozdíl účtu ({0}), musí být ""zisk nebo ztráta"" účet"
DocType: Project,Copied From,Skopírované z
DocType: Project,Copied From,Skopírované z
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +94,Name error: {0},Názov chyba: {0}
apps/erpnext/erpnext/stock/doctype/item/item_list.js +8,Shortage,nedostatok
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +207,{0} {1} does not associated with {2} {3},{0} {1} nie je spojené s {2} {3}
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Účast na zaměstnance {0} je již označen
DocType: Packing Slip,If more than one package of the same type (for print),Pokud je více než jeden balík stejného typu (pro tisk)
,Salary Register,plat Register
DocType: Warehouse,Parent Warehouse,Parent Warehouse
DocType: C-Form Invoice Detail,Net Total,Netto Spolu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +497,Default BOM not found for Item {0} and Project {1},Predvolený kusovník sa nenašiel pre položku {0} a projekt {1}
apps/erpnext/erpnext/config/hr.py +163,Define various loan types,Definovať rôzne typy úverov
DocType: Bin,FCFS Rate,FCFS Rate
DocType: Payment Reconciliation Invoice,Outstanding Amount,Dlužné částky
apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Čas (v min)
DocType: Project Task,Working,Pracovní
DocType: Stock Ledger Entry,Stock Queue (FIFO),Skladové karty (FIFO)
apps/erpnext/erpnext/public/js/setup_wizard.js +109,Financial Year,Finančný rok
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +41,{0} does not belong to Company {1},{0} nepatrí do Spoločnosti {1}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,"Nie je možné vyriešiť funkciu skóre skóre {0}. Skontrolujte, či je vzorec platný."
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +119,Cost as on,Štát ako na
DocType: Account,Round Off,Zaokrúhliť
,Requested Qty,Požadované množství
DocType: Tax Rule,Use for Shopping Cart,Použitie pre Košík
apps/erpnext/erpnext/controllers/item_variant.py +96,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},Hodnota {0} atribútu {1} neexistuje v zozname platného bodu Hodnoty atribútov pre položky {2}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +77,Select Serial Numbers,Vyberte sériové čísla
DocType: BOM Item,Scrap %,Scrap%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Poplatky budou rozděleny úměrně na základě položky Množství nebo částkou, dle Vašeho výběru"
DocType: Maintenance Visit,Purposes,Cíle
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Aspoň jedna položka by mala byť zadaná s negatívnym množstvom vo vratnom dokumente
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Prevádzka {0} dlhšie, než všetkých dostupných pracovných hodín v pracovnej stanici {1}, rozložiť prevádzku do niekoľkých operácií"
,Requested,Požadované
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +89,No Remarks,Žiadne poznámky
DocType: Purchase Invoice,Overdue,Zpožděný
DocType: Account,Stock Received But Not Billed,Prijaté na zásoby ale neúčtované
apps/erpnext/erpnext/accounts/doctype/account/account.py +87,Root Account must be a group,Root účet musí byť skupina
DocType: Fees,FEE.,FEE.
DocType: Employee Loan,Repaid/Closed,Splatená / Zatvorené
DocType: Item,Total Projected Qty,Celková predpokladaná Množstvo
DocType: Monthly Distribution,Distribution Name,Názov distribúcie
DocType: Course,Course Code,kód predmetu
apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},Kontrola kvality potřebný k bodu {0}
DocType: Supplier Scorecard,Supplier Variables,Premenné dodávateľa
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 Item,Net Rate (Company Currency),Čistý Rate (Company meny)
DocType: Salary Detail,Condition and Formula Help,Stav a Formula nápovedy
apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Správa Territory strom.
DocType: Journal Entry Account,Sales Invoice,Predajná faktúra
DocType: Journal Entry Account,Party Balance,Balance Party
apps/erpnext/erpnext/accounts/page/pos/pos.js +474,Please select Apply Discount On,"Prosím, vyberte Použiť Zľava na"
DocType: Company,Default Receivable Account,Výchozí pohledávek účtu
DocType: Process Payroll,Create Bank Entry for the total salary paid for the above selected criteria,Vytvoření bankovní položka pro celkové vyplacené mzdy za výše zvolených kritérií
DocType: Purchase Invoice,Deemed Export,Považovaný export
DocType: Stock Entry,Material Transfer for Manufacture,Materiál Přenos: Výroba
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Sleva v procentech lze použít buď proti Ceníku nebo pro všechny Ceníku.
DocType: Purchase Invoice,Half-yearly,Pololetní
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +400,Accounting Entry for Stock,Účetní položka na skladě
apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +49,You have already assessed for the assessment criteria {}.,Vyhodnotili ste kritériá hodnotenia {}.
DocType: Vehicle Service,Engine Oil,Motorový olej
DocType: Sales Invoice,Sales Team1,Sales Team1
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +39,Item {0} does not exist,Bod {0} neexistuje
DocType: Sales Invoice,Customer Address,Adresa zákazníka
DocType: Employee Loan,Loan Details,pôžička Podrobnosti
DocType: Company,Default Inventory Account,Predvolený inventárny účet
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Riadok {0}: Dokončené množstvo musí byť väčšia ako nula.
DocType: Purchase Invoice,Apply Additional Discount On,Použiť dodatočné Zľava na
DocType: Account,Root Type,Root Type
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Riadok # {0}: Nemožno vrátiť viac ako {1} pre bodu {2}
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +29,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,MJ položky
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Suma dane po zľave Suma (Company meny)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +150,Target warehouse is mandatory for row {0},Target sklad je povinná pro řadu {0}
DocType: Cheque Print Template,Primary Settings,primárnej Nastavenie
DocType: Purchase Invoice,Select Supplier Address,Vybrať Dodávateľ Address
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +380,Add Employees,Pridajte Zamestnanci
DocType: Purchase Invoice Item,Quality Inspection,Kontrola kvality
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +165,Extra Small,Extra Malé
DocType: Company,Standard Template,štandardná šablóna
DocType: Training Event,Theory,teória
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +777,Warning: Material Requested Qty is less than Minimum Order Qty,Upozornění: Materiál Požadované množství je menší než minimální objednávka Množství
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Účet {0} je zmrazen
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,"Právní subjekt / dceřiná společnost s oddělenou Graf účtů, které patří do organizace."
DocType: Payment Request,Mute Email,Mute Email
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +29,"Food, Beverage & Tobacco","Potraviny, nápoje a tabák"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +671,Can only make payment against unbilled {0},Možno vykonať len platbu proti nevyfakturované {0}
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
DocType: Stock Entry,Subcontract,Subdodávka
apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,"Prosím, najprv zadajte {0}"
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +68,No replies from,Žiadne odpovede od
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,Kôš
DocType: SMS Log,No of Sent SMS,Počet odeslaných SMS
DocType: Account,Expense Account,Účtet nákladů
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,Software
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +172,Colour,Farebné
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Plan Assessment Criteria
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Zabráňte nákupným objednávkam
DocType: Training Event,Scheduled,Plánované
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Žiadosť o cenovú ponuku.
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Prosím, vyberte položku, kde &quot;Je skladom,&quot; je &quot;Nie&quot; a &quot;je Sales Item&quot; &quot;Áno&quot; a nie je tam žiadny iný produkt Bundle"
DocType: Student Log,Academic,akademický
apps/erpnext/erpnext/controllers/accounts_controller.py +489,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Celkové zálohy ({0}) na objednávku {1} nemôže byť väčšia ako Celkom ({2})
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Vyberte měsíční výplatou na nerovnoměrně distribuovat cílů napříč měsíců.
DocType: Purchase Invoice Item,Valuation Rate,Ocenění Rate
DocType: Stock Reconciliation,SR/,SR /
DocType: Vehicle,Diesel,motorová nafta
apps/erpnext/erpnext/stock/get_item_details.py +329,Price List Currency not selected,Mena pre cenník nie je vybratá
,Student Monthly Attendance Sheet,Študent mesačná návštevnosť Sheet
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Zamestnanec {0} už požiadal o {1} mezi {2} a {3}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Datum zahájení projektu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +5,Until,Dokud
DocType: Rename Tool,Rename Log,Premenovať Log
apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Plán študentskej skupiny alebo kurzu je povinný
apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Plán študentskej skupiny alebo kurzu je povinný
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Udržiavať fakturácia hodín a pracovnej doby rovnaký na časový rozvrh
DocType: Maintenance Visit Purpose,Against Document No,Proti dokumentu č
DocType: BOM,Scrap,šrot
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Správa prodejních partnerů.
DocType: Quality Inspection,Inspection Type,Kontrola Type
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +131,Warehouses with existing transaction can not be converted to group.,Sklady s existujúcimi transakcie nemožno previesť na skupinu.
DocType: Assessment Result Tool,Result HTML,výsledok HTML
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Vyprší
apps/erpnext/erpnext/utilities/activation.py +115,Add Students,Pridajte študentov
apps/erpnext/erpnext/controllers/recurring_document.py +169,Please select {0},"Prosím, vyberte {0}"
DocType: C-Form,C-Form No,C-Form No
DocType: BOM,Exploded_items,Exploded_items
DocType: Employee Attendance Tool,Unmarked Attendance,Neoznačené Návštevnosť
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +106,Researcher,Výzkumník
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Registrácia do programu Student Tool
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Meno alebo e-mail je povinné
apps/erpnext/erpnext/config/stock.py +163,Incoming quality inspection.,Vstupní kontrola jakosti.
DocType: Purchase Order Item,Returned Qty,Vrátené Množstvo
DocType: Employee,Exit,Východ
apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Root Type is mandatory,Root Type je povinné
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.","{0} v súčasnosti má {1} hodnotiacu kartu pre dodávateľa, a RFQ pre tohto dodávateľa by mali byť vydané opatrne."
DocType: BOM,Total Cost(Company Currency),Celkové náklady (Company mena)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +314,Serial No {0} created,Pořadové číslo {0} vytvořil
DocType: Homepage,Company Description for website homepage,Spoločnosť Popis pre webové stránky domovskú stránku
DocType: Item Customer Detail,"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"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,Meno suplier
DocType: Sales Invoice,Time Sheet List,Zoznam časových rozvrhov
DocType: Employee,You can enter any date manually,Můžete zadat datum ručně
DocType: Asset Category Account,Depreciation Expense Account,Odpisy Náklady účtu
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +194,Probationary Period,Skúšobná 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ů
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Riadok {0}: Advance proti zákazník musí byť úver
apps/erpnext/erpnext/accounts/doctype/account/account.js +83,Non-Group to Group,Non-skupiny k skupine
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Dávka je povinná v riadku {0}
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Dávka je povinná v riadku {0}
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Doklad o koupi Item Dodávané
DocType: Payment Entry,Pay,Platiť
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,Chcete-li datetime
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +54,Course Schedules deleted:,Plány kurzu ruší:
apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Protokoly pre udržanie stavu doručenia sms
DocType: Accounts Settings,Make Payment via Journal Entry,Vykonať platbu cez Journal Entry
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +86,Printed On,Vytlačené na
DocType: Item,Inspection Required before Delivery,Inšpekcia Požadované pred pôrodom
DocType: Item,Inspection Required before Purchase,Inšpekcia Požadované pred nákupom
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Nevybavené Aktivity
apps/erpnext/erpnext/public/js/setup_wizard.js +88,Your Organization,Vaša organizácia
DocType: Fee Component,Fees Category,kategórie poplatky
apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Please enter relieving date.,Zadejte zmírnění datum.
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
DocType: Supplier Scorecard,Notify Employee,Upozorniť zamestnanca
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,"Zadejte název kampaně, pokud zdroj šetření je kampaň"
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +38,Newspaper Publishers,Vydavatelia novín
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Vyberte fiškálny rok
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +114,Expected Delivery Date should be after Sales Order Date,Očakávaný dátum doručenia by mal byť po dátume zákazky predaja
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Změna pořadí Level
DocType: Company,Chart Of Accounts Template,Účtový rozvrh šablóny
DocType: Attendance,Attendance Date,Účast Datum
apps/erpnext/erpnext/stock/get_item_details.py +293,Item Price updated for {0} in Price List {1},Položka Cena aktualizovaný pre {0} v Cenníku {1}
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Plat rozpad na základě Zisk a dedukce.
apps/erpnext/erpnext/accounts/doctype/account/account.py +131,Account with child nodes cannot be converted to ledger,Účet s podřízenými uzly nelze převést na hlavní účetní knihu
DocType: Purchase Invoice Item,Accepted Warehouse,Schválené Sklad
DocType: Bank Reconciliation Detail,Posting Date,Dátum pridania
DocType: Item,Valuation Method,Ocenění Method
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Poldenné
DocType: Sales Invoice,Sales Team,Predajný tím
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +85,Duplicate entry,Duplicitní záznam
DocType: Program Enrollment Tool,Get Students,získať študentov
DocType: Serial No,Under Warranty,V rámci záruky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +491,[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: Student Batch Attendance Tool,Student Batch Attendance Tool,Študent Batch Účasť Tool
apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,limit skríženými
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,Venture Capital
apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Akademický termín s týmto &quot;akademický rok &#39;{0} a&quot; Meno Termín&#39; {1} už existuje. Upravte tieto položky a skúste to znova.
apps/erpnext/erpnext/stock/doctype/item/item.py +462,"As there are existing transactions against item {0}, you can not change the value of {1}",Pretože existujú nejaké transakcie voči položke {0} nemožno zmeniť hodnotu {1}
DocType: UOM,Must be Whole Number,Musí být celé číslo
DocType: Leave Control Panel,New Leaves Allocated (In Days),Nové Listy Přidělené (ve dnech)
DocType: Purchase Invoice,Invoice Copy,Kopírovanie faktúry
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Pořadové číslo {0} neexistuje
DocType: Sales Invoice Item,Customer Warehouse (Optional),Zákazník Warehouse (voliteľne)
DocType: Pricing Rule,Discount Percentage,Sleva v procentech
DocType: Payment Reconciliation Invoice,Invoice Number,Číslo faktúry
DocType: Shopping Cart Settings,Orders,Objednávky
DocType: Employee Leave Approver,Leave Approver,Schvaľovateľ voľna
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +251,Please select a batch,Vyberte dávku
DocType: Assessment Group,Assessment Group Name,Názov skupiny Assessment
DocType: Manufacturing Settings,Material Transferred for Manufacture,Prevádza jadrový materiál pre Výroba
DocType: Expense Claim,"A user with ""Expense Approver"" role","Uživatel s rolí ""Schvalovatel výdajů"""
DocType: Landed Cost Item,Receipt Document Type,Príjem Document Type
DocType: Daily Work Summary Settings,Select Companies,Vyberte firmy
,Issued Items Against Production Order,Vydané předmětů proti výrobní zakázky
DocType: Target Detail,Target Detail,Target Detail
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,všetky Jobs
DocType: Sales Order,% of materials billed against this Sales Order,% Materiálov fakturovaných proti tejto Predajnej objednávke
DocType: Program Enrollment,Mode of Transportation,Spôsob dopravy
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Období Uzávěrka Entry
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Nákladové středisko se stávajícími transakcemi nelze převést do skupiny
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} {2} {3},Množstvo {0} {1} {2} {3}
DocType: Account,Depreciation,Znehodnocení
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Dodavatel (é)
DocType: Employee Attendance Tool,Employee Attendance Tool,Účasť zamestnancov Tool
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Úvěrový limit
DocType: Production Plan Sales Order,Salse Order Date,Dátum predajnej objednávky
DocType: Salary Component,Salary Component,plat Component
apps/erpnext/erpnext/accounts/utils.py +490,Payment Entries {0} are un-linked,Platobné Príspevky {0} sú un-spojený
DocType: GL Entry,Voucher No,Voucher No
,Lead Owner Efficiency,Efektívnosť vlastníka iniciatívy
,Lead Owner Efficiency,Efektívnosť vlastníka iniciatívy
DocType: Leave Allocation,Leave Allocation,Nechte Allocation
DocType: Payment Request,Recipient Message And Payment Details,Príjemca správy a platobných informácií
DocType: Training Event,Trainer Email,tréner Email
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +546,Material Requests {0} created,Materiál Žádosti {0} vytvořené
DocType: Production Planning Tool,Include sub-contracted raw materials,Zahrnúť sub-zmluvné suroviny
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Šablona podmínek nebo smlouvy.
DocType: Purchase Invoice,Address and Contact,Adresa a Kontakt
DocType: Cheque Print Template,Is Account Payable,Je účtu splatný
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +272,Stock cannot be updated against Purchase Receipt {0},Sklad nie je možné aktualizovať proti dokladu o kúpe {0}
DocType: Supplier,Last Day of the Next Month,Posledný deň nasledujúceho mesiaca
DocType: Support Settings,Auto close Issue after 7 days,Auto zavrieť Issue po 7 dňoch
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Dovolenka nemôže byť pridelené pred {0}, pretože rovnováha dovolenky už bolo carry-odovzdávané v budúcej pridelenie dovolenku záznamu {1}"
apps/erpnext/erpnext/accounts/party.py +312,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Poznámka: Z důvodu / Referenční datum překračuje povolené zákazníků úvěrové dní od {0} den (s)
apps/erpnext/erpnext/schools/doctype/program/program.js +8,Student Applicant,študent Žiadateľ
DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINÁL PRE PRÍJEMCU
DocType: Asset Category Account,Accumulated Depreciation Account,účet oprávok
DocType: Stock Settings,Freeze Stock Entries,Freeze Stock Příspěvky
DocType: Program Enrollment,Boarding Student,Stravovanie Študent
DocType: Asset,Expected Value After Useful Life,Očakávaná hodnota po celú dobu životnosti
DocType: Item,Reorder level based on Warehouse,Úroveň Zmena poradia na základe Warehouse
DocType: Activity Cost,Billing Rate,Fakturačná cena
,Qty to Deliver,Množství k dodání
,Stock Analytics,Analýza zásob
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +483,Operations cannot be left blank,Operácia nemôže byť prázdne
DocType: Maintenance Visit Purpose,Against Document Detail No,Proti Detail dokumentu č
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +98,Party Type is mandatory,Typ strana je povinná
DocType: Quality Inspection,Outgoing,Vycházející
DocType: Material Request,Requested For,Požadovaných pro
DocType: Quotation Item,Against Doctype,Proti DOCTYPE
apps/erpnext/erpnext/controllers/buying_controller.py +393,{0} {1} is cancelled or closed,{0} {1} je zrušený alebo zatvorené
DocType: Delivery Note,Track this Delivery Note against any Project,Sledovat tento dodacím listu proti jakémukoli projektu
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Čistý peňažný tok z investičnej
DocType: Production Order,Work-in-Progress Warehouse,Work-in-Progress sklad
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Asset {0} musí byť predložené
apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Účasť Record {0} existuje proti Študent {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Reference # {0} ze dne {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +161,Depreciation Eliminated due to disposal of assets,Odpisy vypadol v dôsledku nakladania s majetkom
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Správa adries
DocType: Asset,Item Code,Kód položky
DocType: Production Planning Tool,Create Production Orders,Vytvoření výrobní zakázky
DocType: Serial No,Warranty / AMC Details,Záruka / AMC Podrobnosti
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Vyberte manuálne študentov pre skupinu založenú na aktivitách
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Vyberte manuálne študentov pre skupinu založenú na aktivitách
DocType: Journal Entry,User Remark,Uživatel Poznámka
DocType: Lead,Market Segment,Segment trhu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +918,Paid Amount cannot be greater than total negative outstanding amount {0},Zaplatená suma nemôže byť vyšší ako celkový negatívny dlžnej čiastky {0}
DocType: Supplier Scorecard Period,Variables,Premenné
DocType: Employee Internal Work History,Employee Internal Work History,Interní historie práce zaměstnance
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +239,Closing (Dr),Uzavření (Dr)
DocType: Cheque Print Template,Cheque Size,šek Veľkosť
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,Pořadové číslo {0} není skladem
apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Daňové šablona na prodej transakce.
DocType: Sales Invoice,Write Off Outstanding Amount,Odepsat dlužné částky
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Účet {0} sa nezhoduje so spoločnosťou {1}
DocType: School Settings,Current Academic Year,Súčasný akademický rok
DocType: School Settings,Current Academic Year,Súčasný akademický rok
DocType: Stock Settings,Default Stock UOM,Východzia skladová MJ
DocType: Asset,Number of Depreciations Booked,Počet Odpisy rezervované
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Proti zamestnancov úveru: {0}
DocType: Landed Cost Item,Receipt Document,príjem dokumentov
DocType: Production Planning Tool,Create Material Requests,Vytvořit Žádosti materiálu
DocType: Employee Education,School/University,Škola / University
DocType: Payment Request,Reference Details,Odkaz Podrobnosti
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Očakávaná hodnota Po celú dobu životnosti musí byť menšie ako Gross sumy nákupu
DocType: Sales Invoice Item,Available Qty at Warehouse,Množství k dispozici na skladu
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Fakturovaná čiastka
DocType: Asset,Double Declining Balance,double degresívne
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +179,Closed order cannot be cancelled. Unclose to cancel.,Uzavretá objednávka nemôže byť zrušený. Otvoriť zrušiť.
DocType: Student Guardian,Father,otec
apps/erpnext/erpnext/controllers/accounts_controller.py +575,'Update Stock' cannot be checked for fixed asset sale,&quot;Aktualizácia Sklad&quot; nemôžu byť kontrolované na pevnú predaji majetku
DocType: Bank Reconciliation,Bank Reconciliation,Bankové odsúhlasenie
DocType: Attendance,On Leave,Na odchode
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Získať aktualizácie
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Účet {2} nepatrí do spoločnosti {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +147,Material Request {0} is cancelled or stopped,Materiál Request {0} je zrušena nebo zastavena
apps/erpnext/erpnext/public/js/setup_wizard.js +395,Add a few sample records,Pridať niekoľko ukážkových záznamov
apps/erpnext/erpnext/config/hr.py +301,Leave Management,Správa priepustiek
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Seskupit podle účtu
DocType: Sales Order,Fully Delivered,Plně Dodáno
DocType: Lead,Lower Income,S nižšími příjmy
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +169,Source and target warehouse cannot be same for row {0},Zdroj a cíl sklad nemůže být stejná pro řádek {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +241,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Rozdiel účet musí byť typu aktív / Zodpovednosť účet, pretože to Reklamná Zmierenie je Entry Otvorenie"
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Zaplatené čiastky nemôže byť väčšia ako Výška úveru {0}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Číslo vydané objednávky je potřebné k položce {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +886,Production Order not created,Zákazková výroba nevytvorili
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',"""Dátum DO"" musí byť po ""Dátum OD"""
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +29,Cannot change status as student {0} is linked with student application {1},Nemôže zmeniť štatút študenta {0} je prepojený s aplikáciou študentské {1}
DocType: Asset,Fully Depreciated,plne odpísaný
,Stock Projected Qty,Naprojektovaná úroveň zásob
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +432,Customer {0} does not belong to project {1},Zákazník {0} nepatří k projektu {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Výrazná Účasť HTML
apps/erpnext/erpnext/utilities/activation.py +71,"Quotations are proposals, bids you have sent to your customers","Ponuky sú návrhy, ponuky zaslané vašim zákazníkom"
DocType: Sales Order,Customer's Purchase Order,Zákazníka Objednávka
apps/erpnext/erpnext/config/stock.py +112,Serial No and Batch,Sériové číslo a Dávka
DocType: Warranty Claim,From Company,Od Společnosti
apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +40,Sum of Scores of Assessment Criteria needs to be {0}.,Súčet skóre hodnotiacich kritérií musí byť {0}.
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Prosím nastavte Počet Odpisy rezervované
DocType: Supplier Scorecard Period,Calculations,výpočty
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Hodnota nebo Množství
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +430,Productions Orders cannot be raised for:,Productions Objednávky nemôže byť zvýšená pre:
apps/erpnext/erpnext/public/js/setup_wizard.js +311,Minute,Minúta
DocType: Purchase Invoice,Purchase Taxes and Charges,Nákup Daně a poplatky
,Qty to Receive,Množství pro příjem
DocType: Leave Block List,Leave Block List Allowed,Nechte Block List povolena
DocType: Grading Scale Interval,Grading Scale Interval,Stupnica Interval
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Náklady Nárok na Vehicle Log {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Zľava (%) na sadzbe cien s maržou
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Zľava (%) na sadzbe cien s maržou
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,všetky Sklady
DocType: Sales Partner,Retailer,Maloobchodník
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +111,Credit To account must be a Balance Sheet account,Pripísať na účet musí byť účtu Súvaha
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Všechny typy Dodavatele
DocType: Global Defaults,Disable In Words,Zakázať v slovách
apps/erpnext/erpnext/stock/doctype/item/item.py +46,Item Code is mandatory because Item is not automatically numbered,"Kód položky je povinné, protože položka není automaticky číslovány"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +97,Quotation {0} not of type {1},Ponuka {0} nie je typu {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Plán údržby Item
DocType: Sales Order,%  Delivered,% Dodaných
DocType: Production Order,PRO-,VO-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Kontokorentní úvěr na účtu
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Proveďte výplatní pásce
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +813,Add All Suppliers,Pridať všetkých dodávateľov
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Riadok # {0}: Pridelená čiastka nemôže byť vyššia ako dlžná suma.
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +40,Browse BOM,Prechádzať BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Zajištěné úvěry
DocType: Purchase Invoice,Edit Posting Date and Time,Úpraviť dátum a čas vzniku
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},"Prosím, amortizácia účty s ním súvisiacich v kategórii Asset {0} alebo {1} Company"
DocType: Academic Term,Academic Year,Akademický rok
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Počiatočný stav Equity
DocType: Lead,CRM,CRM
DocType: Purchase Invoice,N,N
DocType: Appraisal,Appraisal,Ocenění
DocType: Purchase Invoice,GST Details,Podrobnosti GST
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},E-mailu zaslaného na dodávateľa {0}
DocType: Opportunity,OPTY-,OPTY-
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Datum se opakuje
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Prokurista
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},Schvaľujúci musí byť jeden z {0}
DocType: Hub Settings,Seller Email,Prodávající E-mail
DocType: Project,Total Purchase Cost (via Purchase Invoice),Celkové obstarávacie náklady (cez nákupné faktúry)
DocType: Training Event,Start Time,Start Time
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +368,Select Quantity,Zvoľte množstvo
DocType: Customs Tariff Number,Customs Tariff Number,colného sadzobníka
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Schválení role nemůže být stejná jako role pravidlo se vztahuje na
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +65,Unsubscribe from this Email Digest,Odhlásiť sa z tohto Email Digest
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +803,Get Suppliers By,Získajte dodávateľov od
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Správa bola odoslaná
apps/erpnext/erpnext/accounts/doctype/account/account.py +101,Account with child nodes cannot be set as ledger,Účet s podriadené uzly nie je možné nastaviť ako hlavnej knihy
DocType: C-Form,II,II
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,"Sazba, za kterou Ceník měna je převeden na zákazníka základní měny"
DocType: Purchase Invoice Item,Net Amount (Company Currency),Čistá suma (Company Mena)
DocType: Salary Slip,Hour Rate,Hodinová sadzba
DocType: Stock Settings,Item Naming By,Položka Pojmenování By
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Další období Uzávěrka Entry {0} byla podána po {1}
DocType: Production Order,Material Transferred for Manufacturing,Materiál Prenesená pre výrobu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +32,Account {0} does not exists,Účet {0} neexistuje
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 +50,Cost of various activities,Náklady na rôznych aktivít
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Nastavenie udalostí do {0}, pretože zamestnanec pripojená k nižšie predajcom nemá ID užívateľa {1}"
DocType: Timesheet,Billing Details,fakturačné údaje
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +150,Source and target warehouse must be different,Zdrojové a cieľové sklad sa musí líšiť
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Není dovoleno měnit obchodů s akciemi starší než {0}
DocType: Purchase Invoice Item,PR Detail,PR Detail
DocType: 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
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +136,Delivery warehouse required for stock item {0},Dodávka sklad potrebný pre živočíšnu položku {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Celková hmotnost balení. Obvykle se čistá hmotnost + obalového materiálu hmotnosti. (Pro tisk)
apps/erpnext/erpnext/schools/doctype/course/course.js +3,Program,Program
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šené
DocType: Student Group,Group Based On,Skupina založená na
DocType: Student Group,Group Based On,Skupina založená na
DocType: Journal Entry,Bill Date,Bill Datum
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","je nutný servisný položky, typ, frekvencia a množstvo náklady"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","I když existuje více pravidla pro tvorbu cen s nejvyšší prioritou, pak následující interní priority jsou použity:"
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +128,Do you really want to Submit all Salary Slip from {0} to {1},"Naozaj chcete, aby predložili všetky výplatnej páske z {0} až {1}"
DocType: Cheque Print Template,Cheque Height,šek Výška
DocType: Supplier,Supplier Details,Detaily dodávateľa
DocType: Expense Claim,Approval Status,Stav schválení
DocType: Hub Settings,Publish Items to Hub,Publikování položky do Hub
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +43,From value must be less than to value in row {0},Z hodnota musí být menší než hodnota v řadě {0}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +151,Wire Transfer,Bankovní převod
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +132,Check all,"skontrolujte, či všetky"
DocType: Vehicle Log,Invoice Ref,faktúra Ref
DocType: Purchase Order,Recurring Order,Opakujúca se objednávka
DocType: Company,Default Income Account,Účet Default příjmů
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Zákazník Group / Customer
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Neuzavretý fiškálnych rokov Zisk / strata (Credit)
DocType: Sales Invoice,Time Sheets,Časové rozvrhy
DocType: Payment Gateway Account,Default Payment Request Message,Východzí Platba Request Message
DocType: Item Group,Check this if you want to show in website,"Zaškrtněte, pokud chcete zobrazit v webové stránky"
apps/erpnext/erpnext/config/accounts.py +136,Banking and Payments,Bankovníctvo a platby
,Welcome to ERPNext,Vitajte v ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Pretvorenie iniciatívy na ponuku
apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,To je všetko
DocType: Lead,From Customer,Od Zákazníka
apps/erpnext/erpnext/demo/setup/setup_data.py +324,Calls,Volá
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +176,Batches,Šarže
DocType: Project,Total Costing Amount (via Time Logs),Celková kalkulácie Čiastka (cez Time Záznamy)
DocType: Purchase Order Item Supplied,Stock UOM,Skladová MJ
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +229,Purchase Order {0} is not submitted,Vydaná objednávka {0} nie je odoslaná
DocType: Customs Tariff Number,Tariff Number,tarif Počet
DocType: Production Order Item,Available Qty at WIP Warehouse,Dostupné množstvo v WIP Warehouse
apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,Plánovaná
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} does not belong to Warehouse {1},Pořadové číslo {0} nepatří do skladu {1}
apps/erpnext/erpnext/controllers/status_updater.py +174,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,"Poznámka: Systém nebude kontrolovať nad-dodávku a nad-rezerváciu pre Položku {0} , keďže množstvo alebo čiastka je 0"
DocType: Notification Control,Quotation Message,Správa k ponuke
DocType: Employee Loan,Employee Loan Application,Zamestnanec žiadosť o úver
DocType: Issue,Opening Date,Datum otevření
apps/erpnext/erpnext/schools/api.py +77,Attendance has been marked successfully.,Účasť bola úspešne označená.
DocType: Program Enrollment,Public Transport,Verejná doprava
DocType: Journal Entry,Remark,Poznámka
DocType: Purchase Receipt Item,Rate and Amount,Sadzba a množstvo
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +165,Account Type for {0} must be {1},Typ účtu pre {0} musí byť {1}
apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Listy a Holiday
DocType: School Settings,Current Academic Term,Aktuálny akademický výraz
DocType: School Settings,Current Academic Term,Aktuálny akademický výraz
DocType: Sales Order,Not Billed,Nevyúčtované
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +75,Both Warehouse must belong to same Company,Oba Sklady musí patřit do stejné společnosti
apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Žádné kontakty přidán dosud.
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Přistál Náklady Voucher Částka
apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Faktúry od dodávateľov
DocType: POS Profile,Write Off Account,Odepsat účet
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Debit Note Amt,Debetná poznámka Amt
apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Částka slevy
DocType: Purchase Invoice,Return Against Purchase Invoice,Návrat proti nákupnej faktúry
DocType: Item,Warranty Period (in days),Záruční doba (ve dnech)
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Súvislosť s Guardian1
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Čistý peňažný tok z prevádzkovej
apps/erpnext/erpnext/public/js/setup_wizard.js +245,e.g. VAT,napríklad DPH
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Bod 4
DocType: Student Admission,Admission End Date,Vstupné Dátum ukončenia
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +29,Sub-contracting,subdodávky
DocType: Journal Entry Account,Journal Entry Account,Zápis do deníku Účet
apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.js +3,Student Group,študent Group
DocType: Shopping Cart Settings,Quotation Series,Číselná rada ponúk
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +59,"An item exists with same name ({0}), please change the item group name or rename the item","Položka s rovnakým názvom už existuje ({0}), prosím, zmente názov skupiny položiek alebo premenujte položku"
apps/erpnext/erpnext/accounts/page/pos/pos.js +1963,Please select customer,vyberte zákazníka
DocType: C-Form,I,ja
DocType: Company,Asset Depreciation Cost Center,Asset Odpisy nákladového strediska
DocType: Sales Order Item,Sales Order Date,Dátum predajnej objednávky
DocType: Sales Invoice Item,Delivered Qty,Dodává Množství
DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Ak je zaškrtnuté, budú všetky deti každej výrobné položky zahrnuté v materiáli požiadavky."
DocType: Assessment Plan,Assessment Plan,Plan Assessment
DocType: Stock Settings,Limit Percent,limit Percento
,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 +58,Missing Currency Exchange Rates for {0},Chybí Směnárna Kurzy pro {0}
DocType: Assessment Plan,Examiner,skúšajúci
DocType: Student,Siblings,súrodenci
DocType: Journal Entry,Stock Entry,Pohyb zásob
DocType: Payment Entry,Payment References,platobné Referencie
DocType: C-Form,C-FORM-,C-form-
DocType: Vehicle,Insurance Details,poistenie Podrobnosti
DocType: Account,Payable,Splatný
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,"Prosím, zadajte dobu splácania"
apps/erpnext/erpnext/shopping_cart/cart.py +365,Debtors ({0}),Dlžníci ({0})
DocType: Pricing Rule,Margin,Marža
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 +76,Gross Profit %,Hrubý Zisk %
DocType: Appraisal Goal,Weightage (%),Weightage (%)
DocType: Bank Reconciliation Detail,Clearance Date,Výprodej Datum
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Hodnotiaca správa
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Gross Suma nákupu je povinná
DocType: Lead,Address Desc,Popis adresy
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +101,Party is mandatory,Party je povinná
DocType: Journal Entry,JV-,JV-
DocType: Topic,Topic Name,Názov témy
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,Aspoň jeden z prodeje nebo koupě musí být zvolena
apps/erpnext/erpnext/public/js/setup_wizard.js +28,Select the nature of your business.,Vyberte podstatu svojho podnikania.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +73,Row #{0}: Duplicate entry in References {1} {2},Riadok # {0}: Duplicitný záznam v referenciách {1} {2}
apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,"Tam, kde jsou výrobní operace prováděny."
DocType: Asset Movement,Source Warehouse,Zdroj Warehouse
DocType: Installation Note,Installation Date,Datum instalace
apps/erpnext/erpnext/controllers/accounts_controller.py +554,Row #{0}: Asset {1} does not belong to company {2},Riadok # {0}: {1} Asset nepatrí do spoločnosti {2}
DocType: Employee,Confirmation Date,Potvrzení Datum
DocType: C-Form,Total Invoiced Amount,Celková fakturovaná čiastka
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,Min množství nemůže být větší než Max Množství
DocType: Account,Accumulated Depreciation,oprávky
DocType: Supplier Scorecard Scoring Standing,Standing Name,Stály názov
DocType: Stock Entry,Customer or Supplier Details,Zákazníka alebo dodávateľa Podrobnosti
DocType: Employee Loan Application,Required by Date,Vyžadované podľa dátumu
DocType: Lead,Lead Owner,Získateľ Obchodnej iniciatívy
DocType: Bin,Requested Quantity,požadované množstvo
DocType: Employee,Marital Status,Rodinný stav
DocType: Stock Settings,Auto Material Request,Auto materiálu Poptávka
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,K dispozícii dávky Množstvo na Od Warehouse
DocType: Customer,CUST-,CUST-
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Gross Pay - Total dedukcie - splátky
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +26,Current BOM and New BOM can not be same,Aktuální BOM a New BOM nemůže být stejné
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +38,Salary Slip ID,Plat Slip ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date Of Retirement must be greater than Date of Joining,"Datum odchodu do důchodu, musí být větší než Datum spojování"
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +52,There were errors while scheduling course on :,"Došlo k chybám, zatiaľ čo rozvrhovanie kurz na:"
DocType: Sales Invoice,Against Income Account,Proti účet příjmů
apps/erpnext/erpnext/controllers/website_list_for_contact.py +115,{0}% Delivered,{0}% dodané
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +94,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Položka {0}: Objednané množstvo {1} nemôže byť nižšia ako minimálna Objednané množstvo {2} (definovanej v bode).
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
apps/erpnext/erpnext/accounts/utils.py +497,Please set default {0} in Company {1},Prosím nastaviť predvolený {0} vo firme {1}
DocType: Cheque Print Template,Starting position from top edge,Východisková poloha od horného okraja
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +31,Same supplier has been entered multiple times,Rovnaký dodávateľ bol zadaný viackrát
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Hrubý zisk / strata
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Dodané položky vydané objednávky
apps/erpnext/erpnext/public/js/setup_wizard.js +129,Company Name cannot be Company,Názov spoločnosti nemôže byť Company
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."
DocType: Program Enrollment,Walking,chôdza
DocType: Student Guardian,Student Guardian,študent Guardian
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +201,Valuation type charges can not marked as Inclusive,Poplatky typu ocenenie môže nie je označený ako Inclusive
DocType: POS Profile,Update Stock,Aktualizace skladem
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: Asset,Journal Entry for Scrap,Zápis do denníka do šrotu
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,"Prosím, vytáhněte položky z dodací list"
apps/erpnext/erpnext/accounts/utils.py +467,Journal Entries {0} are un-linked,Zápisů {0} jsou un-spojený
apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Záznam všetkých oznámení typu e-mail, telefón, chát, návštevy, atď"
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Hodnotenie skóre dodávateľa
DocType: Manufacturer,Manufacturers used in Items,Výrobcovia používané v bodoch
apps/erpnext/erpnext/accounts/general_ledger.py +145,Please mention Round Off Cost Center in Company,"Prosím, uveďte zaokrúhliť nákladové stredisko v spoločnosti"
DocType: Purchase Invoice,Terms,Podmínky
DocType: Academic Term,Term Name,termín Name
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,Analýza nákupu
DocType: Sales Invoice Item,Delivery Note Item,Delivery Note Item
DocType: Expense Claim,Task,Úkol
DocType: Purchase Taxes and Charges,Reference Row #,Referenční Row #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Číslo šarže je povinné pro položku {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,To je kořen prodejní člověk a nelze upravovat.
DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Ak je vybratá, hodnota špecifikovaná alebo vypočítaná v tejto zložke neprispieva k výnosom alebo odpočtom. Avšak, jeho hodnota môže byť odkazovaná na iné komponenty, ktoré môžu byť pridané alebo odpočítané."
DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Ak je vybratá, hodnota špecifikovaná alebo vypočítaná v tejto zložke neprispieva k výnosom alebo odpočtom. Avšak, jeho hodnota môže byť odkazovaná na iné komponenty, ktoré môžu byť pridané alebo odpočítané."
,Stock Ledger,Súpis zásob
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Sadzba: {0}
DocType: Company,Exchange Gain / Loss Account,Exchange Zisk / straty
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Zamestnancov a dochádzky
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +78,Purpose must be one of {0},Cíl musí být jedním z {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,Fill the form and save it,Vyplňte formulář a uložte jej
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/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Navštívte komunitné fórum
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Aktuálne množstvo na sklade
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Aktuálne množstvo na sklade
DocType: Homepage,"URL for ""All Products""",URL pre &quot;všetky produkty&quot;
DocType: Leave Application,Leave Balance Before Application,Nechte zůstatek před aplikací
DocType: SMS Center,Send SMS,Poslať SMS
DocType: Supplier Scorecard Criteria,Max Score,Maximálny výsledok
DocType: Cheque Print Template,Width of amount in word,Šírka sumy v slove
DocType: Company,Default Letter Head,Výchozí hlavičkový
DocType: Purchase Order,Get Items from Open Material Requests,Získať predmety z žiadostí Otvoriť Materiál
DocType: Item,Standard Selling Rate,Štandardné predajné kurz
DocType: Account,Rate at which this tax is applied,"Rychlost, při které se používá tato daň"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +65,Reorder Qty,Změna pořadí Množství
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Aktuálne pracovné príležitosti
DocType: Company,Stock Adjustment Account,Reklamní Nastavení účtu
apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Odpísať
DocType: Timesheet Detail,Operation ID,Prevádzka 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/manufacturing/doctype/bom_update_tool/bom_update_tool.py +48,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Naliehavá aktualizácia najnovšej ceny vo všetkých účtovných dokladoch. Môže to trvať niekoľko minút.
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,"Názov nového účtu. Poznámka: Prosím, vytvárať účty pre zákazníkov a dodávateľmi"
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Země moudrý výchozí adresa Templates
DocType: Sales Order Item,Supplier delivers to Customer,Dodávateľ doručí zákazníkovi
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Položka / {0}) nie je na sklade
apps/erpnext/erpnext/controllers/recurring_document.py +177,Next Date must be greater than Posting Date,Ďalšie Dátum musí byť väčšia ako Dátum zverejnenia
apps/erpnext/erpnext/accounts/party.py +315,Due / Reference Date cannot be after {0},Vzhledem / Referenční datum nemůže být po {0}
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Import dát a export
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +71,No students Found,Žiadni študenti Nájdené
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Hodnotiace kritériá pre dodávateľa Scorecard
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Faktúra Dátum zverejnenia
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Predať
DocType: Sales Invoice,Rounded Total,Zaoblený Total
DocType: Product Bundle,List items that form the package.,"Seznam položek, které tvoří balíček."
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Podíl alokace by měla být ve výši 100%
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +569,Please select Posting Date before selecting Party,"Prosím, vyberte Dátum zverejnenia pred výberom Party"
DocType: Program Enrollment,School House,School House
DocType: Serial No,Out of AMC,Out of AMC
apps/erpnext/erpnext/public/js/utils.js +245,Please select Quotations,Vyberte prosím ponuky
apps/erpnext/erpnext/public/js/utils.js +245,Please select Quotations,Vyberte prosím ponuky
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Počet Odpisy rezervované nemôže byť väčšia ako celkový počet Odpisy
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Proveďte návštěv údržby
apps/erpnext/erpnext/selling/doctype/customer/customer.py +167,Please contact to the user who have Sales Master Manager {0} role,"Prosím, kontaktujte pro uživatele, kteří mají obchodní manažer ve skupině Master {0} roli"
DocType: Company,Default Cash Account,Výchozí Peněžní účet
apps/erpnext/erpnext/config/accounts.py +56,Company (not Customer or Supplier) master.,Company (nikoliv zákazník nebo dodavatel) master.
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,To je založené na účasti tohto študenta
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Žiadni študenti v
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +166,Add more items or open full form,Pridať ďalšie položky alebo otvorené plnej forme
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +206,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Dodací listy {0} musí být zrušena před zrušením této prodejní objednávky
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +81,Paid amount + Write Off Amount can not be greater than Grand Total,Placená částka + odepsat Částka nesmí být větší než Grand Total
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} nie je platné číslo Šarže pre Položku {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Note: There is not enough leave balance for Leave Type {0},Poznámka: Není k dispozici dostatek zůstatek dovolené dovolená za kalendářní typ {0}
apps/erpnext/erpnext/regional/india/utils.py +15,Invalid GSTIN or Enter NA for Unregistered,Neplatné GSTIN alebo Enter NA pre neregistrované
DocType: Training Event,Seminar,seminár
DocType: Program Enrollment Fee,Program Enrollment Fee,program zápisné
DocType: Item,Supplier Items,Dodavatele položky
DocType: Opportunity,Opportunity Type,Typ Příležitosti
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Nová spoločnost
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Transakcie môžu byť vymazané len tvorca Spoloč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.
DocType: Employee,Prefered Contact Email,Preferovaný Kontaktný e-mail
DocType: Cheque Print Template,Cheque Width,šek Šírka
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Overenie predajná cena výtlačku proti platbe alebo ocenenia Rate
DocType: Program,Fee Schedule,poplatok Plán
DocType: Hub Settings,Publish Availability,Publikování Dostupnost
DocType: Company,Create Chart Of Accounts Based On,Vytvorte účtový rozvrh založený na
apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date of Birth cannot be greater than today.,Dátum narodenia nemôže byť väčšia ako dnes.
,Stock Ageing,Starnutie zásob
apps/erpnext/erpnext/schools/doctype/student/student.py +38,Student {0} exist against student applicant {1},Existujú Študent {0} proti uchádzač študent {1}
apps/erpnext/erpnext/projects/doctype/task/task.js +31,Timesheet,pracovný výkaz
apps/erpnext/erpnext/controllers/accounts_controller.py +246,{0} '{1}' is disabled,{0} '{1}' je vypnuté
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Nastaviť ako Otvorené
DocType: Cheque Print Template,Scanned Cheque,skenovaných Šek
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Posílat automatické e-maily na Kontakty na předložení transakcí.
DocType: Timesheet,Total Billable Amount,Celková suma Fakturovateľná
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Položka 3
DocType: Purchase Order,Customer Contact Email,Zákazník Kontaktný e-mail
DocType: Warranty Claim,Item and Warranty Details,Položka a Záruka Podrobnosti
DocType: Sales Team,Contribution (%),Příspěvek (%)
apps/erpnext/erpnext/controllers/accounts_controller.py +83,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,"Poznámka: Položka Platba nebude vytvořili, protože ""v hotovosti nebo bankovním účtu"" nebyl zadán"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +200,Responsibilities,Zodpovednosť
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +127,Validity period of this quotation has ended.,Platnosť tejto ponuky sa skončila.
DocType: Expense Claim Account,Expense Claim Account,Náklady na poistné Account
DocType: Sales Person,Sales Person Name,Meno predajcu
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Zadejte prosím aspoň 1 fakturu v tabulce
apps/erpnext/erpnext/public/js/setup_wizard.js +198,Add Users,Pridať používateľa
DocType: POS Item Group,Item Group,Položka Group
DocType: Item,Safety Stock,bezpečnostné Sklad
apps/erpnext/erpnext/projects/doctype/task/task.py +53,Progress % for a task cannot be more than 100.,Pokrok% za úlohu nemôže byť viac ako 100.
DocType: Stock Reconciliation Item,Before reconciliation,Pred odsúhlasením
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Chcete-li {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Daně a poplatky Přidal (Company měna)
apps/erpnext/erpnext/stock/doctype/item/item.py +433,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,"Položka Tax Row {0} musí mít účet typu daní či výnosů nebo nákladů, nebo Vyměřovací"
DocType: Sales Order,Partly Billed,Částečně Účtovaný
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Item {0} musí byť dlhodobý majetok položka
DocType: Item,Default BOM,Výchozí BOM
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Výška dlžnej sumy
apps/erpnext/erpnext/setup/doctype/company/company.js +50,Please re-type company name to confirm,Prosím re-typ názov spoločnosti na potvrdenie
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +79,Total Outstanding Amt,Celkem Vynikající Amt
DocType: Journal Entry,Printing Settings,Nastavenie tlače
DocType: Sales Invoice,Include Payment (POS),Zahŕňajú platby (POS)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Celkové inkaso musí rovnat do celkového kreditu. Rozdíl je {0}
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +11,Automotive,Automobilový
DocType: Vehicle,Insurance Company,Poisťovňa
DocType: Asset Category Account,Fixed Asset Account,Fixed Asset Account
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Variable,premenlivý
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Z Dodacího Listu
DocType: Student,Student Email Address,Študent E-mailová adresa
DocType: Timesheet Detail,From Time,Času od
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Na sklade:
DocType: Notification Control,Custom Message,Custom Message
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +33,Investment Banking,Investiční bankovnictví
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +77,Cash or Bank Account is mandatory for making payment entry,V hotovosti nebo bankovním účtu je povinný pro výrobu zadání platebního
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Adresa študenta
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Adresa študenta
DocType: Purchase Invoice,Price List Exchange Rate,Katalogová cena Exchange Rate
DocType: Purchase Invoice Item,Rate,Sadzba
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +73,Intern,Internovat
apps/erpnext/erpnext/accounts/page/pos/pos.js +1533,Address Name,Meno adresy
DocType: Stock Entry,From BOM,Od BOM
DocType: Assessment Code,Assessment Code,kód Assessment
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +42,Basic,Základné
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Skladové transakcie pred {0} sú zmrazené
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',"Prosím, klikněte na ""Generovat Schedule"""
apps/erpnext/erpnext/config/stock.py +190,"e.g. Kg, Unit, Nos, m","napríklad Kg, ks, m"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,"Referenční číslo je povinné, pokud jste zadali k rozhodnému dni"
DocType: Bank Reconciliation Detail,Payment Document,platba Document
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Chyba pri hodnotení kritéria kritérií
apps/erpnext/erpnext/hr/doctype/employee/employee.py +110,Date of Joining must be greater than Date of Birth,Datum přistoupení musí být větší než Datum narození
DocType: Salary Slip,Salary Structure,Plat struktura
DocType: Account,Bank,Banka
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +9,Airline,Letecká linka
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +818,Issue Material,Vydání Material
DocType: Material Request Item,For Warehouse,Pro Sklad
DocType: Employee,Offer Date,Dátum Ponuky
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Ponuky
apps/erpnext/erpnext/accounts/page/pos/pos.js +692,You are in offline mode. You will not be able to reload until you have network.,"Ste v režime offline. Nebudete môcť znovu, kým nebudete mať sieť."
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Žiadne študentské skupiny vytvorený.
DocType: Purchase Invoice Item,Serial No,Výrobní číslo
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Mesačné splátky suma nemôže byť vyššia ako suma úveru
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,"Prosím, zadejte první maintaince Podrobnosti"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +55,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Riadok # {0}: Predpokladaný dátum doručenia nemôže byť pred dátumom objednávky
DocType: Purchase Invoice,Print Language,Jazyk tlače
DocType: Salary Slip,Total Working Hours,Celkovej pracovnej doby
DocType: Stock Entry,Including items for sub assemblies,Vrátane položiek pre montážnych podskupín
apps/erpnext/erpnext/accounts/page/pos/pos.js +1892,Enter value must be positive,Zadajte hodnota musí byť kladná
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +389,All Territories,Všetky územia
DocType: Purchase Invoice,Items,Položky
apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +26,Student is already enrolled.,Študent je už zapísané.
DocType: Fiscal Year,Year Name,Meno roku
DocType: Process Payroll,Process Payroll,Proces Payroll
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +238,There are more holidays than working days this month.,Existují další svátky než pracovních dnů tento měsíc.
DocType: Product Bundle Item,Product Bundle Item,Položka produktového balíčka
DocType: Sales Partner,Sales Partner Name,Meno predajného partnera
apps/erpnext/erpnext/hooks.py +119,Request for Quotations,Žiadosť o citátov
DocType: Payment Reconciliation,Maximum Invoice Amount,Maximálna suma faktúry
DocType: Student Language,Student Language,študent Language
apps/erpnext/erpnext/config/selling.py +23,Customers,Zákazníci
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Objednávka / kvóta%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Objednávka / kvóta%
DocType: Student Sibling,Institution,inštitúcie
DocType: Asset,Partially Depreciated,čiastočne odpíše
DocType: Issue,Opening Time,Otevírací doba
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Data OD a DO jsou vyžadována
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +46,Securities & Commodity Exchanges,Cenné papíry a komoditních burzách
apps/erpnext/erpnext/stock/doctype/item/item.py +625,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Východzí merná jednotka varianty &#39;{0}&#39; musí byť rovnaký ako v Template &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Vypočítať na základe
DocType: Delivery Note Item,From Warehouse,Zo skladu
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +887,No Items with Bill of Materials to Manufacture,Žiadne položky s Bill of Materials Výroba
DocType: Assessment Plan,Supervisor Name,Meno Supervisor
DocType: Program Enrollment Course,Program Enrollment Course,Program na zápis do programu
DocType: Program Enrollment Course,Program Enrollment Course,Program na zápis do programu
DocType: Purchase Taxes and Charges,Valuation and Total,Oceňování a Total
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,scorecards
DocType: Tax Rule,Shipping City,Mesto dodania
DocType: Notification Control,Customize the Notification,Přizpůsobit oznámení
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Cash flow z prevádzkových činností
DocType: Sales Invoice,Shipping Rule,Prepravné pravidlo
DocType: Manufacturer,Limited to 12 characters,Obmedzené na 12 znakov
DocType: Journal Entry,Print Heading,Hlavička tlače
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Celkem nemůže být nula
DocType: Training Event Employee,Attended,navštevoval
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,"""Dní od poslednej objednávky"" musí byť väčšie alebo rovnajúce sa nule"
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Prosím, nastavte číselnú sériu pre účasť cez Setup&gt; Numbering Series"
DocType: Process Payroll,Payroll Frequency,mzdové frekvencia
DocType: Asset,Amended From,Platném znění
apps/erpnext/erpnext/public/js/setup_wizard.js +307,Raw Material,Surovina
DocType: Leave Application,Follow via Email,Sledovat e-mailem
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Rastliny a strojné vybavenie
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Částka daně po slevě Částka
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Každodennú prácu Súhrnné Nastavenie
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +258,Currency of the price list {0} is not similar with the selected currency {1},Mena cenníka {0} nie je podobné s vybranou menou {1}
DocType: Payment Entry,Internal Transfer,vnútorné Prevod
apps/erpnext/erpnext/accounts/doctype/account/account.py +179,Child account exists for this account. You can not delete this account.,Dětské konto existuje pro tento účet. Nemůžete smazat tento účet.
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 +527,No default BOM exists for Item {0},No default BOM existuje pro bod {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +359,Please select Posting Date first,"Prosím, vyberte najprv Dátum zverejnenia"
apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Dátum začatia by mala byť pred uzávierky
DocType: Leave Control Panel,Carry Forward,Převádět
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Nákladové středisko se stávajícími transakcemi nelze převést na hlavní účetní knihy
DocType: Department,Days for which Holidays are blocked for this department.,"Dnů, po které Prázdniny jsou blokovány pro toto oddělení."
,Produced,Produkoval
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +118,Created Salary Slips,Vytvorené výplatných páskach
DocType: Item,Item Code for Suppliers,Položka Kód pre dodávateľa
DocType: Issue,Raised By (Email),Vznesené (e-mail)
DocType: Training Event,Trainer Name,Meno tréner
DocType: Mode of Payment,General,Všeobecný
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Posledná komunikácia
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Posledná komunikácia
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +355,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Nelze odečíst, pokud kategorie je určena pro ""ocenění"" nebo ""oceňování a celkový"""
apps/erpnext/erpnext/public/js/setup_wizard.js +238,"List your tax heads (e.g. VAT, Customs etc; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Vypíšte vaše používané dane (napr DPH, Clo atď; mali by mať jedinečné názvy) a ich štandardné sadzby. Týmto sa vytvorí štandardná šablóna, ktorú môžete upraviť a pridať ďalšie neskôr."
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},Serial Nos Požadováno pro serializovaném bodu {0}
apps/erpnext/erpnext/config/accounts.py +146,Match Payments with Invoices,Spárovať úhrady s faktúrami
DocType: Journal Entry,Bank Entry,Bank Entry
DocType: Authorization Rule,Applicable To (Designation),Vztahující se na (označení)
,Profitability Analysis,Analýza ziskovosti
DocType: Supplier,Prevent POs,Zabráňte organizáciám výrobcov
apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Přidat do košíku
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Seskupit podle
DocType: Guardian,Interests,záujmy
apps/erpnext/erpnext/config/accounts.py +300,Enable / disable currencies.,Povolit / zakázat měny.
DocType: Production Planning Tool,Get Material Request,Získať Materiál Request
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Poštovní náklady
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Total (Amt)
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,Entertainment & Leisure
DocType: Quality Inspection,Item Serial No,Položka Výrobní číslo
apps/erpnext/erpnext/utilities/activation.py +133,Create Employee Records,Vytvoriť zamestnanecké záznamy
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Celkem Present
apps/erpnext/erpnext/config/accounts.py +107,Accounting Statements,účtovná závierka
apps/erpnext/erpnext/public/js/setup_wizard.js +311,Hour,Hodina
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,"New Pořadové číslo nemůže mít Warehouse. Warehouse musí být nastaveny Stock vstupním nebo doklad o koupi,"
DocType: Lead,Lead Type,Typ Iniciatívy
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Nie ste oprávnení schvaľovať lístie na bloku Termíny
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +383,All these items have already been invoiced,Všechny tyto položky již byly fakturovány
apps/erpnext/erpnext/public/js/setup_wizard.js +228,Monthly Sales Target,Mesačný cieľ predaja
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Může být schválena {0}
DocType: Item,Default Material Request Type,Východiskový materiál Typ požiadavky
DocType: Supplier Scorecard,Evaluation Period,Hodnotiace obdobie
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,nevedno
DocType: Shipping Rule,Shipping Rule Conditions,Přepravní Článek Podmínky
DocType: Purchase Invoice,Export Type,Typ exportu
DocType: BOM Update Tool,The new BOM after replacement,Nový BOM po výměně
apps/erpnext/erpnext/accounts/page/pos/pos.js +659,Point of Sale,Miesto predaja
DocType: Payment Entry,Received Amount,prijatej Suma
DocType: GST Settings,GSTIN Email Sent On,GSTIN E-mail odoslaný na
DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop od Guardian
DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Vytvorte pre celkové množstvo, ignorujte množstvo už na objednávke"
DocType: Account,Tax,Daň
apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,neoznačený
DocType: Production Planning Tool,Production Planning Tool,Plánování výroby Tool
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry",Doručená položka {0} sa nedá aktualizovať pomocou odsúhlasenia skladových položiek
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +150,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry",Doručená položka {0} sa nedá aktualizovať pomocou odsúhlasenia skladových položiek
DocType: Quality Inspection,Report Date,Datum Reportu
DocType: Student,Middle Name,Stredné meno
DocType: C-Form,Invoices,Faktúry
DocType: Batch,Source Document Name,Názov zdrojového dokumentu
DocType: Batch,Source Document Name,Názov zdrojového dokumentu
DocType: Job Opening,Job Title,Název pozice
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.","{0} znamená, že {1} neposkytne ponuku, ale boli citované všetky položky \. Aktualizácia stavu ponuky RFQ."
DocType: Manufacturing Settings,Update BOM Cost Automatically,Automaticky sa aktualizuje cena kusovníka
apps/erpnext/erpnext/utilities/activation.py +97,Create Users,vytvoriť užívateľa
apps/erpnext/erpnext/public/js/setup_wizard.js +311,Gram,gram
DocType: Supplier Scorecard,Per Month,Za mesiac
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +393,Quantity to Manufacture must be greater than 0.,"Množstvo, ktoré má výroba musí byť väčšia ako 0 ° C."
apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Navštivte zprávu pro volání údržby.
DocType: Stock Entry,Update Rate and Availability,Obnovovaciu rýchlosť a dostupnosť
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.,"Percento, ktoré máte možnosť prijať alebo dodať naviac oproti objednanému množstvu. Napríklad: Keď ste si objednali 100 kusov a váša tolerancia je 10%, tak máte možnosť prijať 110 kusov."
DocType: POS Customer Group,Customer Group,Zákazník Group
apps/erpnext/erpnext/stock/doctype/batch/batch.js +108,New Batch ID (Optional),Nové číslo dávky (voliteľné)
apps/erpnext/erpnext/stock/doctype/batch/batch.js +108,New Batch ID (Optional),Nové číslo dávky (voliteľné)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +197,Expense account is mandatory for item {0},Účtet nákladů je povinný pro položku {0}
DocType: BOM,Website Description,Popis webu
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Čistá zmena vo vlastnom imaní
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +163,Please cancel Purchase Invoice {0} first,Zrušte faktúre {0} prvý
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","E-mailová adresa musí byť jedinečná, už existuje pre {0}"
DocType: Serial No,AMC Expiry Date,AMC Datum vypršení platnosti
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +815,Receipt,príjem
,Sales Register,Sales Register
DocType: Daily Work Summary Settings Company,Send Emails At,Posielať e-maily At
DocType: Quotation,Quotation Lost Reason,Dôvod neúspešnej ponuky
apps/erpnext/erpnext/public/js/setup_wizard.js +15,Select your Domain,Vyberte si doménu
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364,Transaction reference no {0} dated {1},Referenčné transakcie no {0} z {1}
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Není nic upravovat.
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +117,Summary for this month and pending activities,Zhrnutie pre tento mesiac a prebiehajúcim činnostiam
DocType: Customer Group,Customer Group Name,Zákazník Group Name
apps/erpnext/erpnext/public/js/pos/pos.html +100,No Customers yet!,Zatiaľ žiadni zákazníci!
apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Prehľad o peňažných tokoch
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Výška úveru nesmie prekročiť maximálnu úveru Suma {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,licencie
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +479,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
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Nastavte pomenovanie série {0} cez Nastavenie&gt; Nastavenia&gt; Pomenovanie série
DocType: Item,Attributes,Atribúty
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,Please enter Write Off Account,"Prosím, zadejte odepsat účet"
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Posledná Dátum objednávky
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Účet {0} nie je patria spoločnosti {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +855,Serial Numbers in row {0} does not match with Delivery Note,Sériové čísla v riadku {0} sa nezhodujú s dodacím listom
DocType: Student,Guardian Details,Guardian Podrobnosti
DocType: C-Form,C-Form,C-Form
apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark dochádzky pre viac zamestnancov
DocType: Vehicle,Chassis No,podvozok Žiadne
DocType: Payment Request,Initiated,Zahájil
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: Leave Allocation,New Leaves Allocated,Nové Listy Přidělené
apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Data dle projektu nejsou k dispozici pro nabídku
DocType: Project,Expected End Date,Očekávané datum ukončení
DocType: Budget Account,Budget Amount,rozpočet Suma
DocType: Appraisal Template,Appraisal Template Title,Posouzení Template Název
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Od dátumu {0} pre zamestnancov {1} nemôže byť ešte pred vstupom Dátum zamestnanca {2}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +114,Commercial,Obchodní
DocType: Payment Entry,Account Paid To,účet Venovaná
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Parent Item {0} nesmie byť skladom
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Všechny výrobky nebo služby.
DocType: Expense Claim,More Details,Další podrobnosti
DocType: Supplier Quotation,Supplier Address,Dodavatel Address
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} Rozpočet na účet {1} proti {2} {3} je {4}. To bude presahovať o {5}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +668,Row {0}# Account must be of type 'Fixed Asset',Riadok {0} # účet musí byť typu &quot;Fixed Asset&quot;
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Out Množství
apps/erpnext/erpnext/config/accounts.py +316,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 +34,Series is mandatory,Série je povinné
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,Finanční služby
DocType: Student Sibling,Student ID,Študentská karta
apps/erpnext/erpnext/config/projects.py +45,Types of activities for Time Logs,Typy činností pre Time Záznamy
DocType: Tax Rule,Sales,Predaj
DocType: Stock Entry Detail,Basic Amount,Základná čiastka
DocType: Training Event,Exam,skúška
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +450,Warehouse required for stock Item {0},Sklad je vyžadován pro skladovou položku {0}
DocType: Leave Allocation,Unused leaves,Nepoužité listy
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Zákazník&gt; Zákaznícka skupina&gt; Územie
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +179,Cr,Cr
DocType: Tax Rule,Billing State,Fakturačný štát
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +287,Transfer,Převod
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +882,Fetch exploded BOM (including sub-assemblies),Fetch explodovala kusovníku (včetně montážních podskupin)
DocType: Authorization Rule,Applicable To (Employee),Vztahující se na (Employee)
apps/erpnext/erpnext/controllers/accounts_controller.py +123,Due Date is mandatory,Dátum splatnosti je povinný
apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Prírastok pre atribút {0} nemôže byť 0
DocType: Journal Entry,Pay To / Recd From,Platit K / Recd Z
DocType: Naming Series,Setup Series,Řada Setup
DocType: Payment Reconciliation,To Invoice Date,Ak chcete dátumu vystavenia faktúry
DocType: Supplier,Contact HTML,Kontakt HTML
,Inactive Customers,Neaktívni zákazníci
DocType: Landed Cost Voucher,LCV,LCV
DocType: Landed Cost Voucher,Purchase Receipts,Příjmky
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Jak Ceny pravidlo platí?
DocType: Stock Entry,Delivery Note No,Dodacího listu
DocType: Production Planning Tool,"If checked, only Purchase material requests for final raw materials will be included in the Material Requests. Otherwise, Material Requests for parent items will be created","Ak je zaškrtnuté, je možné zakúpiť len materiálne Žiadosti o konečné surovín budú zahrnuté v materiáli požiadavky. V opačnom prípade bude vytvorený Materiál Žiadosti o materskej kusov"
DocType: Cheque Print Template,Message to show,správa ukázať
DocType: Company,Retail,Maloobchod
DocType: Attendance,Absent,Nepřítomný
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +566,Product Bundle,Produktový balíček
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Nepodarilo sa nájsť skóre od {0}. Musíte mať stály počet bodov od 0 do 100
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Riadok {0}: Neplatné referencie {1}
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Kúpte Dane a poplatky šablóny
DocType: Upload Attendance,Download Template,Stáhnout šablonu
DocType: Timesheet,TS-,TS-
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: buď debetnou alebo kreditnou čiastku je nutné pre {2}
DocType: GL Entry,Remarks,Poznámky
DocType: Payment Entry,Account Paid From,Účet sú platení z prostriedkov
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
apps/erpnext/erpnext/utilities/activation.py +63,Make Lead,urobiť Lead
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Tlač a papiernictva
DocType: Stock Settings,Show Barcode Field,Show čiarového kódu Field
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +782,Send Supplier Emails,Poslať Dodávateľ e-maily
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Plat už spracované pre obdobie medzi {0} a {1}, ponechajte dobu použiteľnosti nemôže byť medzi tomto časovom období."
apps/erpnext/erpnext/config/stock.py +127,Installation record for a Serial No.,Instalace rekord pro sériové číslo
DocType: Guardian Interest,Guardian Interest,Guardian Záujem
apps/erpnext/erpnext/config/hr.py +177,Training,výcvik
DocType: Timesheet,Employee Detail,Detail zamestnanca
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,ID e-mailu Guardian1
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,ID e-mailu Guardian1
apps/erpnext/erpnext/controllers/recurring_document.py +190,Next Date's day and Repeat on Day of Month must be equal,deň nasledujúcemu dňu a Opakujte na deň v mesiaci sa musí rovnať
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Nastavenie titulnej stránky webu
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +38,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQ nie sú povolené pre {0} kvôli postaveniu skóre {1}
DocType: Offer Letter,Awaiting Response,Čaká odpoveď
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Vyššie
apps/erpnext/erpnext/controllers/item_variant.py +217,Invalid attribute {0} {1},Neplatný atribút {0} {1}
DocType: Supplier,Mention if non-standard payable account,"Uveďte, či je neštandardný splatný účet"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +303,Same item has been entered multiple times. {list},Rovnaká položka bola zadaná viackrát. {List}
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Vyberte inú hodnotiacu skupinu ako &quot;Všetky hodnotiace skupiny&quot;
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Riadok {0}: Pre položku {1} sa vyžaduje nákladové centrum.
DocType: Salary Slip,Earning & Deduction,Príjem a odpočty
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,Volitelné. Toto nastavení bude použito k filtrování v různých transakcí.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +108,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/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Prozatímní Zisk / ztráta (Credit)
DocType: Sales Invoice,Return Against Sales Invoice,Návrat proti predajnej faktúre
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Bod 5
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
DocType: Sales Invoice,Product Bundle Help,Product Bundle Help
,Monthly Attendance Sheet,Měsíční Účast Sheet
DocType: Production Order Item,Production Order Item,Výroba objednávku Položka
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +19,No record found,Nebyl nalezen žádný záznam
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost of Scrapped Asset,Náklady na vyradenie aktív
apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Nákladové stredisko je povinné pre položku {2}
DocType: Vehicle,Policy No,nie politika
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +659,Get Items from Product Bundle,Získať predmety z Bundle Product
DocType: Asset,Straight Line,Priamka
DocType: Project User,Project User,projekt Užívateľ
apps/erpnext/erpnext/stock/doctype/batch/batch.js +59,Split,Rozdeliť
apps/erpnext/erpnext/stock/doctype/batch/batch.js +59,Split,Rozdeliť
DocType: GL Entry,Is Advance,Je Zálohová
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Účast Datum od a docházky do dnešního dne je povinná
apps/erpnext/erpnext/controllers/buying_controller.py +151,Please enter 'Is Subcontracted' as Yes or No,"Prosím, zadejte ""subdodavatelům"" jako Ano nebo Ne"
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Dátum poslednej komunikácie
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Dátum poslednej komunikácie
DocType: Sales Team,Contact No.,Kontakt Číslo
DocType: Bank Reconciliation,Payment Entries,platobné Príspevky
DocType: Production Order,Scrap Warehouse,šrot Warehouse
DocType: Production Order,Check if material transfer entry is not required,"Skontrolujte, či sa nepožaduje zadávanie materiálu"
DocType: Production Order,Check if material transfer entry is not required,"Skontrolujte, či sa nepožaduje zadávanie materiálu"
DocType: Program Enrollment Tool,Get Students From,Získať študentov z
DocType: Hub Settings,Seller Country,Prodejce Country
apps/erpnext/erpnext/config/learn.py +273,Publish Items on Website,Publikovať položky na webových stránkach
apps/erpnext/erpnext/utilities/activation.py +124,Group your students in batches,Skupina vaši študenti v dávkach
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 +85,Specifications,Specifikace
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Predaj Dane a poplatky šablóny
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Celkový (Credit)
DocType: Repayment Schedule,Payment Date,Dátum platby
apps/erpnext/erpnext/stock/doctype/batch/batch.js +102,New Batch Qty,Nová dávková dávka
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +10,Apparel & Accessories,Oblečení a doplňky
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,"Funkciu váženého skóre sa nepodarilo vyriešiť. Skontrolujte, či je vzorec platný."
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Číslo objednávky
DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, které se zobrazí na první místo v seznamu výrobků."
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Stanovte podmienky na výpočet výšky prepravných nákladov
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Role povoleno nastavit zmrazené účty a upravit Mražené Příspěvky
DocType: Supplier Scorecard Scoring Variable,Path,cesta
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,"Nelze převést nákladového střediska na knihy, protože má podřízené uzly"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +56,Opening Value,otvorenie Value
DocType: Salary Detail,Formula,vzorec
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Provize z prodeje
DocType: Offer Letter Term,Value / Description,Hodnota / Popis
apps/erpnext/erpnext/controllers/accounts_controller.py +578,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Riadok # {0}: Asset {1} nemôže byť predložený, je už {2}"
DocType: Tax Rule,Billing Country,Fakturačná krajina
DocType: Purchase Order Item,Expected Delivery Date,Očekávané datum dodání
apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debetné a kreditné nerovná za {0} # {1}. Rozdiel je v tom {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Výdaje na reprezentaci
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +48,Make Material Request,Vytvoriť žiadosť na materiál
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Otvorená Položka {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Prodejní faktury {0} musí být zrušena před zrušením této prodejní objednávky
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +60,Age,Věk
DocType: Sales Invoice Timesheet,Billing Amount,Fakturovaná čiastka
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žstvo uvedené pre položku {0}. Množstvo by malo byť väčšie než 0.
apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Žádosti o dovolenou.
apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account with existing transaction can not be deleted,Účet s transakcemi nemůže být smazán
DocType: Vehicle,Last Carbon Check,Posledné Carbon Check
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Výdavky na právne služby
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +113,Please select quantity on row ,Vyberte prosím množstvo na riadku
DocType: Purchase Invoice,Posting Time,Čas zadání
DocType: Timesheet,% Amount Billed,% Fakturovanej čiastky
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Telefonní Náklady
DocType: Sales Partner,Logo,Logo
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,"Zaškrtněte, pokud chcete, aby uživateli vybrat sérii před uložením. Tam bude žádná výchozí nastavení, pokud jste zkontrolovat."
apps/erpnext/erpnext/stock/get_item_details.py +135,No Item with Serial No {0},No Položka s Serial č {0}
DocType: Email Digest,Open Notifications,Otvorené Oznámenie
DocType: Payment Entry,Difference Amount (Company Currency),Rozdiel Suma (Company mena)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Přímé náklady
apps/erpnext/erpnext/controllers/recurring_document.py +213,"{0} is an invalid email address in 'Notification \
						Email Address'",{0} je neplatná e-mailová adresa v &quot;Oznámenie \ &#39;e-mailovú adresu
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Nový zákazník Příjmy
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Cestovní výdaje
DocType: Maintenance Visit,Breakdown,Rozbor
apps/erpnext/erpnext/controllers/accounts_controller.py +690,Account: {0} with currency: {1} can not be selected,Účet: {0} s menou: {1} nemožno vybrať
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.",Aktualizujte náklady na BOM automaticky prostredníctvom Plánovača na základe najnovšej sadzby ocenenia / cien / posledného nákupu surovín.
DocType: Bank Reconciliation Detail,Cheque Date,Šek Datum
apps/erpnext/erpnext/accounts/doctype/account/account.py +54,Account {0}: Parent account {1} does not belong to company: {2},Účet {0}: Nadřazený účet {1} nepatří ke společnosti: {2}
DocType: Program Enrollment Tool,Student Applicants,študent Žiadatelia
apps/erpnext/erpnext/setup/doctype/company/company.js +67,Successfully deleted all transactions related to this company!,Úspešne vypúšťa všetky transakcie súvisiace s týmto spoločnosti!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Rovnako ako u Date
DocType: Appraisal,HR,HR
DocType: Program Enrollment,Enrollment Date,zápis Dátum
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +69,Probation,Skúšobná lehota
apps/erpnext/erpnext/config/hr.py +115,Salary Components,mzdové Components
DocType: Program Enrollment Tool,New Academic Year,Nový akademický rok
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +762,Return / Credit Note,Return / dobropis
DocType: Stock Settings,Auto insert Price List rate if missing,Automaticky vložiť cenníkovú cenu ak neexistuje
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23,Total Paid Amount,Celkem uhrazené částky
DocType: Production Order Item,Transferred Qty,Přenesená Množství
apps/erpnext/erpnext/config/learn.py +11,Navigating,Navigácia
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +157,Planning,Plánování
DocType: Material Request,Issued,Vydané
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +14,Student Activity,Aktivita študentov
DocType: Project,Total Billing Amount (via Time Logs),Celkom Billing Suma (cez Time Záznamy)
apps/erpnext/erpnext/public/js/setup_wizard.js +314,We sell this Item,Táto položka je na predaj
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,Dodavatel Id
DocType: Payment Request,Payment Gateway Details,Platobná brána Podrobnosti
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +253,Quantity should be greater than 0,Množstvo by mala byť väčšia ako 0
apps/erpnext/erpnext/public/js/setup_wizard.js +392,Sample Data,Ukážkové údaje
DocType: Journal Entry,Cash Entry,Cash Entry
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Podriadené uzly môžu byť vytvorené len na základe typu uzly &quot;skupina&quot;
DocType: Leave Application,Half Day Date,Half Day Date
DocType: Academic Year,Academic Year Name,Akademický rok Meno
DocType: Sales Partner,Contact Desc,Kontakt Popis
apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Typ ponechává jako neformální, nevolnosti atd."
DocType: Email Digest,Send regular summary reports via Email.,Zasílat pravidelné souhrnné zprávy e-mailem.
DocType: Payment Entry,PE-,PE
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +254,Please set default account in Expense Claim Type {0},Prosím nastaviť predvolený účet v Expense reklamačný typu {0}
DocType: Assessment Result,Student Name,Meno študenta
DocType: Brand,Item Manager,Manažér položiek
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,mzdové Splatné
DocType: Buying Settings,Default Supplier Type,Výchozí typ Dodavatel
DocType: Production Order,Total Operating Cost,Celkové provozní náklady
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Poznámka: Položka {0} vstoupil vícekrát
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Všechny kontakty.
apps/erpnext/erpnext/public/js/setup_wizard.js +225,Set your Target,Nastavte svoj cieľ
apps/erpnext/erpnext/public/js/setup_wizard.js +62,Company Abbreviation,Skratka názvu spoločnosti
apps/erpnext/erpnext/hr/doctype/employee/employee.py +136,User {0} does not exist,Uživatel: {0} neexistuje
DocType: Item Attribute Value,Abbreviation,Zkratka
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +179,Payment Entry already exists,Platba Entry už existuje
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Není authroized od {0} překročí limity
apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Plat master šablona.
DocType: Leave Type,Max Days Leave Allowed,Max Days Leave povolena
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Sada Daňové Pravidlo pre nákupného košíka
DocType: Purchase Invoice,Taxes and Charges Added,Daně a poplatky přidané
,Sales Funnel,Predajný lievik
apps/erpnext/erpnext/setup/doctype/company/company.py +48,Abbreviation is mandatory,Skratka je povinná
DocType: Project,Task Progress,pokrok úloha
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Vozík
,Qty to Transfer,Množství pro přenos
apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Ponuka z Obchodnej Iniciatívy alebo pre Zákazníka
DocType: Stock Settings,Role Allowed to edit frozen stock,Role povoleno upravovat zmrazené zásoby
,Territory Target Variance Item Group-Wise,Území Cílová Odchylka Item Group-Wise
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +112,All Customer Groups,Všechny skupiny zákazníků
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,nahromadené za mesiac
apps/erpnext/erpnext/controllers/accounts_controller.py +651,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} je povinné. Možno nie je vytvorený záznam Zmeny meny pre {1} až {2}.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +40,Tax Template is mandatory.,Daňová šablóna je povinné.
apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} does not exist,Účet {0}: Nadřazený účet {1} neexistuje
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Cenníková cena (mena firmy)
DocType: Products Settings,Products Settings,nastavenie Produkty
DocType: Account,Temporary,Dočasný
DocType: Program,Courses,predmety
DocType: Monthly Distribution Percentage,Percentage Allocation,Procento přidělení
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +97,Secretary,Sekretárka
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Pokiaľ zakázať, &quot;v slovách&quot; poli nebude viditeľný v akejkoľvek transakcie"
DocType: Serial No,Distinct unit of an Item,Samostatnou jednotku z položky
DocType: Supplier Scorecard Criteria,Criteria Name,Názov kritéria
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1209,Please set Company,Nastavte spoločnosť
DocType: Pricing Rule,Buying,Nákupy
DocType: HR Settings,Employee Records to be created by,Zamestnanecké záznamy na vytvorenie kým
DocType: POS Profile,Apply Discount On,Použiť Zľava na
,Reqd By Date,Pr p Podľa dátumu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Věřitelé
DocType: Assessment Plan,Assessment Name,Názov Assessment
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Riadok # {0}: Výrobné číslo je povinné
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Položka Wise Tax Detail
apps/erpnext/erpnext/public/js/setup_wizard.js +62,Institute Abbreviation,inštitút Skratka
,Item-wise Price List Rate,Item-moudrý Ceník Rate
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +916,Supplier Quotation,Dodávateľská ponuka
DocType: Quotation,In Words will be visible once you save the Quotation.,"Ve slovech budou viditelné, jakmile uložíte nabídku."
apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},Množstvo ({0}) nemôže byť zlomkom v riadku {1}
apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},Množstvo ({0}) nemôže byť zlomkom v riadku {1}
apps/erpnext/erpnext/schools/doctype/fees/fees.js +26,Collect Fees,vyberať poplatky
DocType: Attendance,ATT-,ATT-
apps/erpnext/erpnext/stock/doctype/item/item.py +445,Barcode {0} already used in Item {1},Čárový kód {0} již použit u položky {1}
apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Pravidla pro přidávání náklady na dopravu.
DocType: Item,Opening Stock,otvorenie Sklad
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Je nutná zákazník
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} je povinné pre návrat
DocType: Purchase Order,To Receive,Obdržať
apps/erpnext/erpnext/public/js/setup_wizard.js +207,user@example.com,user@example.com
DocType: Employee,Personal Email,Osobný e-mail
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Celkový rozptyl
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Pokud je povoleno, bude systém odesílat účetní položky k zásobám automaticky."
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +15,Brokerage,Makléřská
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Účasť na zamestnancov {0} je už označený pre tento deň
DocType: Production Order Operation,"in Minutes
Updated via 'Time Log'","v minútach 
 aktualizované pomocou ""Time Log"""
DocType: Customer,From Lead,Od Obchodnej iniciatívy
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Objednávky uvolněna pro výrobu.
apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Vyberte fiškálny rok ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +555,POS Profile required to make POS Entry,"POS Profile požadované, aby POS Vstup"
DocType: Program Enrollment Tool,Enroll Students,zapísať študenti
DocType: Hub Settings,Name Token,Názov Tokenu
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Štandardný predaj
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +138,Atleast one warehouse is mandatory,Alespoň jeden sklad je povinný
DocType: Serial No,Out of Warranty,Out of záruky
DocType: BOM Update Tool,Replace,Vyměnit
apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Nenašli sa žiadne produkty.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} proti Predajnej Faktúre {1}
DocType: Sales Invoice,SINV-,SINV-
DocType: Request for Quotation Item,Project Name,Název projektu
DocType: Customer,Mention if non-standard receivable account,Zmienka v prípade neštandardnej pohľadávky účet
DocType: Journal Entry Account,If Income or Expense,Pokud je výnos nebo náklad
DocType: Production Order,Required Items,povinné predmety
DocType: Stock Ledger Entry,Stock Value Difference,Rozdiel v hodnote zásob
apps/erpnext/erpnext/config/learn.py +234,Human Resource,Ľudské Zdroje
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 +38,Tax Assets,Daňové Aktiva
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +625,Production Order has been {0},Výrobná zákazka bola {0}
DocType: BOM Item,BOM No,BOM No
DocType: Instructor,INS/,INS /
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,Journal Entry {0} does not have account {1} or already matched against other voucher,Zápis do deníku {0} nemá účet {1} nebo již uzavřeno proti ostatním poukaz
DocType: Item,Moving Average,Klouzavý průměr
DocType: BOM Update Tool,The BOM which will be replaced,"BOM, který bude nahrazen"
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,elektronické zariadenia
DocType: Account,Debit,Debet
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,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 +29,Upload attendance from a .csv file,Nahrajte účast ze souboru CSV
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Vynikající Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Nastavit cíle Item Group-moudrý pro tento prodeje osobě.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Freeze Zásoby Starší než [dny]
apps/erpnext/erpnext/controllers/accounts_controller.py +548,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Riadok # {0}: Prostriedok je povinné pre dlhodobého majetku nákup / predaj
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Pokud dva nebo více pravidla pro tvorbu cen se nacházejí na základě výše uvedených podmínek, priorita je aplikována. Priorita je číslo od 0 do 20, zatímco výchozí hodnota je nula (prázdný). Vyšší číslo znamená, že bude mít přednost, pokud existuje více pravidla pro tvorbu cen se za stejných podmínek."
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiškálny rok: {0} neexistuje
DocType: Currency Exchange,To Currency,Chcete-li měny
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Nechte následující uživatelé schválit Žádost o dovolenou.
apps/erpnext/erpnext/config/hr.py +132,Types of Expense Claim.,Druhy výdajů nároku.
apps/erpnext/erpnext/controllers/selling_controller.py +173,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Miera predaja pre položku {0} je nižšia ako {1}. Miera predaja by mala byť najmenej {2}
apps/erpnext/erpnext/controllers/selling_controller.py +173,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Miera predaja pre položku {0} je nižšia ako {1}. Miera predaja by mala byť najmenej {2}
DocType: Item,Taxes,Daně
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +324,Paid and Not Delivered,Platená a nie je doručenie
DocType: Project,Default Cost Center,Výchozí Center Náklady
DocType: Bank Guarantee,End Date,Datum ukončení
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Transackia na zásobách
DocType: Budget,Budget Accounts,rozpočtové účty
DocType: Employee,Internal Work History,Vnitřní práce History
DocType: Depreciation Schedule,Accumulated Depreciation Amount,oprávky Suma
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Private Equity
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Premenná ukazovateľa tabuľky dodávateľov
DocType: Employee Loan,Fully Disbursed,úplne vyčerpaný
DocType: Maintenance Visit,Customer Feedback,Zpětná vazba od zákazníků
DocType: Account,Expense,Výdaj
apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.js +34,Score cannot be greater than Maximum Score,Skóre nemôže byť väčšia ako maximum bodov
DocType: Item Attribute,From Range,Od Rozsah
DocType: BOM,Set rate of sub-assembly item based on BOM,Nastavte rýchlosť položky podsúboru na základe kusovníka
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Syntax error in formula or condition: {0},syntaktická chyba vo vzorci alebo stave: {0}
DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Každodennú prácu Súhrnné Nastavenie Company
apps/erpnext/erpnext/stock/utils.py +123,Item {0} ignored since it is not a stock item,"Položka {0} ignorována, protože to není skladem"
DocType: Appraisal,APRSL,APRSL
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +101,Submit this Production Order for further processing.,Odeslat tento výrobní zakázka pro další zpracování.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Nechcete-li použít Ceník článek v dané transakce, by měly být všechny platné pravidla pro tvorbu cen zakázáno."
DocType: Assessment Group,Parent Assessment Group,Materská skupina Assessment
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,jobs
,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 +36,Production Item,Výrobná položka
,Employee Information,Informace o zaměstnanci
apps/erpnext/erpnext/public/js/setup_wizard.js +247,Rate (%),Sadzba (%)
DocType: Stock Entry Detail,Additional Cost,Dodatočné náklady
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"Can not filter based on Voucher No, if grouped by Voucher","Nelze filtrovat na základě poukazu ne, pokud seskupeny podle poukazu"
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +891,Make Supplier Quotation,Vytvoriť ponuku od dodávateľa
DocType: Quality Inspection,Incoming,Přicházející
DocType: BOM,Materials Required (Exploded),Potřebný materiál (Rozložený)
apps/erpnext/erpnext/public/js/setup_wizard.js +199,"Add users to your organization, other than yourself",Pridanie ďalších používateľov do vašej organizácie okrem Vás
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',"Filtrovanie spoločnosti nastavte prázdne, ak je položka Skupina pod skupinou &quot;Spoločnosť&quot;"
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Vysielanie dátum nemôže byť budúci dátum
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Riadok # {0}: Výrobné číslo {1} nezodpovedá {2} {3}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +55,Casual Leave,Casual Leave
DocType: Batch,Batch ID,Šarže ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Poznámka: {0}
,Delivery Note Trends,Dodací list Trendy
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,This Week's Summary,Tento týždeň Zhrnutie
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +20,In Stock Qty,Na sklade Množstvo
apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Účet: {0} lze aktualizovat pouze prostřednictvím Skladových Transakcí
DocType: Student Group Creation Tool,Get Courses,získať kurzy
DocType: GL Entry,Party,Strana
DocType: Sales Order,Delivery Date,Dodávka Datum
DocType: Opportunity,Opportunity Date,Příležitost Datum
DocType: Purchase Receipt,Return Against Purchase Receipt,Návrat Proti doklad o kúpe
DocType: Request for Quotation Item,Request for Quotation Item,Žiadosť o cenovú ponuku výtlačku
DocType: Purchase Order,To Bill,Billa
DocType: Material Request,% Ordered,% Objednané
DocType: School Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",V prípade kurzov študentskej skupiny bude kurz potvrdený pre každého študenta z prihlásených kurzov pri zaradení do programu.
DocType: Purchase Invoice,"Enter Email Address separated by commas, invoice will be mailed automatically on particular date","Zadajte e-mailovú adresu od seba oddelené čiarkou, faktúra bude automaticky zaslaný na určitý dátum"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +72,Piecework,Úkolová práce
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Avg. Buying Rate,Avg. Nákup Rate
DocType: Task,Actual Time (in Hours),Skutočná doba (v hodinách)
DocType: Employee,History In Company,Historie ve Společnosti
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Newslettery
DocType: Stock Ledger Entry,Stock Ledger Entry,Zápis do súpisu zásob
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +82,Same item has been entered multiple times,Rovnaký bod bol zadaný viackrát
DocType: Department,Leave Block List,Nechte Block List
DocType: Sales Invoice,Tax ID,DIČ
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,Položka {0} není nastavení pro Serial č. Sloupec musí být prázdný
DocType: Accounts Settings,Accounts Settings,Nastavenie účtu
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +7,Approve,schvaľovať
DocType: Customer,Sales Partner and Commission,Partner predaja a provízia
DocType: Employee Loan,Rate of Interest (%) / Year,Úroková sadzba (%) / rok
,Project Quantity,projekt Množstvo
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Total {0} u všetkých položiek je nulová, môže byť by ste mali zmeniť, Distribuovať poplatkov na základe &#39;"
DocType: Opportunity,To Discuss,K projednání
apps/erpnext/erpnext/stock/stock_ledger.py +368,{0} units of {1} needed in {2} to complete this transaction.,{0} jednotiek {1} potrebná {2} pre dokončenie tejto transakcie.
DocType: Loan Type,Rate of Interest (%) Yearly,Úroková sadzba (%) Ročné
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Dočasné Účty
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +176,Black,Čierna
DocType: BOM Explosion Item,BOM Explosion Item,BOM Explosion Item
DocType: Account,Auditor,Auditor
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +124,{0} items produced,{0} predmety vyrobené
DocType: Cheque Print Template,Distance from top edge,Vzdialenosť od horného okraja
apps/erpnext/erpnext/stock/get_item_details.py +308,Price List {0} is disabled or does not exist,Cenníková cena {0} je zakázaná alebo neexistuje
DocType: Purchase Invoice,Return,Spiatočná
DocType: Production Order Operation,Production Order Operation,Výrobní zakázka Operace
DocType: Pricing Rule,Disable,Zakázat
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +161,Mode of payment is required to make a payment,Spôsob platby je povinný vykonať platbu
DocType: Project Task,Pending Review,Čeká Review
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +38,{0} - {1} is not enrolled in the Batch {2},{0} - {1} nie je zapísaná v dávke {2}
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","Aktíva {0} nemôže byť vyhodený, ako je to už {1}"
DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Claim (via Expense nároku)
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Označiť ako neprítomný
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +139,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Riadok {0}: Mena BOM # {1} by sa mala rovnať vybranej mene {2}
DocType: Journal Entry Account,Exchange Rate,Výmenný kurz
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +573,Sales Order {0} is not submitted,Prodejní objednávky {0} není předložena
DocType: Homepage,Tag Line,tag linka
DocType: Fee Component,Fee Component,poplatok Component
apps/erpnext/erpnext/config/hr.py +195,Fleet Management,fleet management
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +914,Add items from,Pridať položky z
DocType: Cheque Print Template,Regular,pravidelný
apps/erpnext/erpnext/schools/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Celkový weightage všetkých hodnotiacich kritérií musí byť 100%
DocType: BOM,Last Purchase Rate,Posledná nákupná cena
DocType: Account,Asset,Majetek
DocType: Project Task,Task ID,Task ID
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,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: Training Event,Contact Number,Kontaktné číslo
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +72,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 +37,The selected item cannot have Batch,Vybraná položka nemůže mít dávku
apps/erpnext/erpnext/stock/stock_ledger.py +464,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a sample item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Ocenenie rýchlosť nebola nájdená pre výtlačku {0}, ktorý je na to účtovné položky pre požadované {1} {2}. Ak je položka vybavovať ako položka vzorky v {1}, prosím spomenúť, že v {1} tabuľky položky. V opačnom prípade vytvorte prichádzajúce legálne transakciu za položku alebo zmienka rýchlosťou ocenenie v zázname položky a skúste odovzdanie / zrušenie tejto položky"
DocType: Delivery Note,% of materials delivered against this Delivery Note,% materiálov dodaných proti tomuto dodaciemu listu
DocType: Project,Customer Details,Podrobnosti zákazníků
DocType: Employee,Reports to,Zprávy
,Unpaid Expense Claim,Neplatené Náklady nárok
DocType: Payment Entry,Paid Amount,Uhrazené částky
DocType: Assessment Plan,Supervisor,Nadriadený
apps/erpnext/erpnext/accounts/page/pos/pos.js +719,Online,online
,Available Stock for Packing Items,K dispozici skladem pro balení položek
DocType: Item Variant,Item Variant,Variant Položky
DocType: Assessment Result Tool,Assessment Result Tool,Assessment Tool Výsledok
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
apps/erpnext/erpnext/accounts/page/pos/pos.js +880,Submitted orders can not be deleted,Predložené objednávky nemožno zmazať
apps/erpnext/erpnext/accounts/doctype/account/account.py +117,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Zůstatek na účtu již v inkasa, není dovoleno stanovit ""Balance musí být"" jako ""úvěru"""
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +87,Quality Management,Řízení kvality
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +41,Item {0} has been disabled,Item {0} bol zakázaný
DocType: Employee Loan,Repay Fixed Amount per Period,Splácať paušálna čiastka za obdobie
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Zadajte prosím množstvo pre Položku {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +78,Credit Note Amt,Kreditná poznámka Amt
DocType: Employee External Work History,Employee External Work History,Externá pracovná história zamestnanca
DocType: Tax Rule,Purchase,Nákup
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Zostatkové množstvo
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Bránky nemôže byť prázdny
DocType: Item Group,Parent Item Group,Parent Item Group
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} pre {1}
apps/erpnext/erpnext/setup/doctype/company/company.js +25,Cost Centers,Nákladové středisko
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,"Sazba, za kterou dodavatel měny je převeden na společnosti základní měny"
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: časování v rozporu s řadou {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Povoliť sadzbu nulového oceňovania
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Povoliť sadzbu nulového oceňovania
DocType: Training Event Employee,Invited,pozvaný
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +175,Multiple active Salary Structures found for employee {0} for the given dates,Viac aktívny Plat Structures nájdených pre zamestnancov {0} pre dané termíny
apps/erpnext/erpnext/config/accounts.py +310,Setup Gateway accounts.,Nastavenia brány účty.
DocType: Employee,Employment Type,Typ zaměstnání
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Dlouhodobý majetek
DocType: Payment Entry,Set Exchange Gain / Loss,Set Exchange zisk / strata
,GST Purchase Register,Registrácia nákupov GST
,Cash Flow,Cash Flow
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Obdobie podávania žiadostí nemôže byť na dvoch alokácie záznamy
DocType: Item Group,Default Expense Account,Výchozí výdajového účtu
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,Študent ID e-mailu
DocType: Employee,Notice (days),Oznámenie (dni)
DocType: Tax Rule,Sales Tax Template,Daň z predaja Template
apps/erpnext/erpnext/accounts/page/pos/pos.js +2397,Select items to save the invoice,"Vyberte položky, ktoré chcete uložiť faktúru"
DocType: Employee,Encashment Date,Inkaso Datum
DocType: Training Event,Internet,internet
DocType: Account,Stock Adjustment,Úprava skladových zásob
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Existuje Náklady Predvolené aktivity pre Typ aktivity - {0}
DocType: Production Order,Planned Operating Cost,Plánované provozní náklady
DocType: Academic Term,Term Start Date,Termín Dátum začatia
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Opp Count
apps/erpnext/erpnext/controllers/recurring_document.py +136,Please find attached {0} #{1},V příloze naleznete {0} # {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Bankový zostatok podľa hlavnej knihy
DocType: Job Applicant,Applicant Name,Žadatel Název
DocType: Authorization Rule,Customer / Item Name,Zákazník / Název zboží
DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

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

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 Product Bundle Item.

Note: BOM = Bill of Materials","Súhrnný skupina ** položiek ** do iného ** Položka **. To je užitočné, ak sa zväzovanie niektoré položky ** ** do balíka a budete udržiavať zásoby balených ** Položky ** a nie agregát ** položky **. Balíček ** Položka ** bude mať &quot;Je skladom,&quot; ako &quot;Nie&quot; a &quot;Je predaja Item&quot; ako &quot;Yes&quot;. Napríklad: Ak predávate notebooky a batohy oddelene a majú špeciálnu cenu, ak zákazník kúpi obidva, potom Laptop + Backpack bude nový Bundle Product Item. Poznámka: BOM = Nomenklatúra"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Pořadové číslo je povinná k bodu {0}
DocType: Item Variant Attribute,Attribute,Atribút
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Uveďte z / do rozmedzie
DocType: Serial No,Under AMC,Podle AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Bod míra ocenění je přepočítána zvažuje přistál nákladů částku poukazu
apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Výchozí nastavení pro prodejní transakce.
DocType: Guardian,Guardian Of ,Guardian Of
DocType: Grading Scale Interval,Threshold,Prah
DocType: BOM Update Tool,Current BOM,Aktuální BOM
apps/erpnext/erpnext/public/js/utils.js +45,Add Serial No,Přidat Sériové číslo
DocType: Production Order Item,Available Qty at Source Warehouse,Dostupné množstvo v zdrojovom sklade
apps/erpnext/erpnext/config/support.py +22,Warranty,záruka
DocType: Purchase Invoice,Debit Note Issued,vydanie dlhopisu
DocType: Production Order,Warehouses,Sklady
apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} pohľadávku nemôže byť prevedená
apps/erpnext/erpnext/stock/doctype/item/item.js +66,This Item is a Variant of {0} (Template).,Táto položka je variantom {0} (šablóna).
DocType: Workstation,per hour,za hodinu
apps/erpnext/erpnext/config/buying.py +7,Purchasing,nákup
DocType: Announcement,Announcement,oznámenia
DocType: School Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",V prípade dávkovej študentskej skupiny bude študentská dávka schválená pre každého študenta zo zápisu do programu.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,"Warehouse nelze vypustit, neboť existuje zásob, kniha pro tento sklad."
DocType: Company,Distribution,Distribúcia
apps/erpnext/erpnext/schools/doctype/fees/fees.js +27,Amount Paid,Zaplacené částky
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +102,Project Manager,Project Manager
,Quoted Item Comparison,Citoval Položka Porovnanie
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Prekrývajúci sa bodovanie medzi {0} a {1}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +83,Dispatch,Odeslání
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,Max discount allowed for item: {0} is {1}%,Max sleva povoleno položku: {0} {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Net Asset value as on,Čistá hodnota aktív aj na
DocType: Account,Receivable,Pohledávky
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +288,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,"Riadok # {0}: Nie je povolené meniť dodávateľa, objednávky už existuje"
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,"Role, která se nechá podat transakcí, které přesahují úvěrové limity."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +919,Select Items to Manufacture,Vyberte položky do výroby
apps/erpnext/erpnext/accounts/page/pos/pos.js +944,"Master data syncing, it might take some time","Kmeňové dáta synchronizácia, môže to trvať nejaký čas"
DocType: Item,Material Issue,Material Issue
DocType: Hub Settings,Seller Description,Prodejce Popis
DocType: Employee Education,Qualification,Kvalifikace
DocType: Item Price,Item Price,Položka Cena
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +48,Soap & Detergent,Soap & Detergent
DocType: BOM,Show Items,Zobraziť položky
apps/erpnext/erpnext/schools/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Od doby nemôže byť väčšia ako na čas.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +36,Motion Picture & Video,Motion Picture & Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Objednáno
DocType: Salary Detail,Component,komponentov
DocType: Assessment Criteria,Assessment Criteria Group,Hodnotiace kritériá Group
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Otvorenie Oprávky musí byť menšia ako rovná {0}
DocType: Warehouse,Warehouse Name,Název Skladu
DocType: Naming Series,Select Transaction,Vybrat Transaction
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Zadejte Schvalování role nebo Schvalování Uživatel
DocType: Journal Entry,Write Off Entry,Odepsat Vstup
DocType: BOM,Rate Of Materials Based On,Hodnotit materiálů na bázi
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Podpora Analtyics
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +142,Uncheck all,Zrušte zaškrtnutie políčka všetko
DocType: POS Profile,Terms and Conditions,Podmínky
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},"Chcete-li data by měla být v rámci fiskálního roku. Za předpokladu, že To Date = {0}"
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Zde si můžete udržet výšku, váhu, alergie, zdravotní problémy atd"
DocType: Leave Block List,Applies to Company,Platí pre firmu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +202,Cannot cancel because submitted Stock Entry {0} exists,"Nelze zrušit, protože předložena Reklamní Entry {0} existuje"
DocType: Employee Loan,Disbursement Date,vyplatenie Date
DocType: BOM Update Tool,Update latest price in all BOMs,Aktualizujte najnovšiu cenu vo všetkých kusovníkoch
DocType: Vehicle,Vehicle,vozidlo
DocType: Purchase Invoice,In Words,Slovy
DocType: POS Profile,Item Groups,položka Skupiny
apps/erpnext/erpnext/hr/doctype/employee/employee.py +217,Today is {0}'s birthday!,Dnes je {0} 's narozeniny!
DocType: Production Planning Tool,Material Request For Warehouse,Materiál Request For Warehouse
DocType: Sales Order Item,For Production,Pro Výrobu
DocType: Payment Request,payment_url,payment_url
DocType: Project Task,View Task,Zobraziť Task
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Olovo%
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Olovo%
DocType: Material Request,MREQ-,MREQ-
,Asset Depreciations and Balances,Asset Odpisy a zostatkov
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +353,Amount {0} {1} transferred from {2} to {3},Množstvo {0} {1} prevedená z {2} na {3}
DocType: Sales Invoice,Get Advances Received,Získat přijaté zálohy
DocType: Email Digest,Add/Remove Recipients,Přidat / Odebrat příjemce
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +461,Transaction not allowed against stopped Production Order {0},Transakce není povoleno proti zastavila výrobu Objednat {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Chcete-li nastavit tento fiskální rok jako výchozí, klikněte na tlačítko ""Nastavit jako výchozí"""
apps/erpnext/erpnext/projects/doctype/project/project.py +200,Join,pripojiť
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Nedostatek Množství
apps/erpnext/erpnext/stock/doctype/item/item.py +649,Item variant {0} exists with same attributes,Variant Položky {0} existuje s rovnakými vlastnosťami
DocType: Employee Loan,Repay from Salary,Splatiť z platu
DocType: Leave Application,LAP/,LAP /
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +341,Requesting payment against {0} {1} for amount {2},Požiadavka na platbu proti {0} {1} na sumu {2}
DocType: Salary Slip,Salary Slip,Plat Slip
DocType: Lead,Lost Quotation,stratil Citácia
DocType: Pricing Rule,Margin Rate or Amount,Marža sadzbou alebo pevnou sumou
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,"""Dátum 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,Položka predajnej objednávky
DocType: Salary Slip,Payment Days,Platební dny
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +121,Warehouses with child nodes cannot be converted to ledger,Sklady s podriadené uzlami nemožno previesť do hlavnej účtovnej knihy
DocType: BOM,Manage cost of operations,Správa nákladů na provoz
DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Když některý z kontrolovaných operací je ""Odesláno"", email pop-up automaticky otevřeny poslat e-mail na přidružené ""Kontakt"" v této transakci, s transakcí jako přílohu. Uživatel může, ale nemusí odeslat e-mail."
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Globálne nastavenia
DocType: Assessment Result Detail,Assessment Result Detail,Posúdenie Detail Výsledok
DocType: Employee Education,Employee Education,Vzdelávanie zamestnancov
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +48,Duplicate item group found in the item group table,Duplicitné skupinu položiek uvedené v tabuľke na položku v skupine
apps/erpnext/erpnext/public/js/controllers/transaction.js +941,It is needed to fetch Item Details.,"Je potrebné, aby priniesla Detaily položky."
DocType: Salary Slip,Net Pay,Net Pay
DocType: Account,Account,Účet
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,Pořadové číslo {0} již obdržel
,Requested Items To Be Transferred,Požadované položky mají být převedeny
DocType: Expense Claim,Vehicle Log,jázd
DocType: Purchase Invoice,Recurring Id,Id opakujúceho sa
DocType: Customer,Sales Team Details,Podrobnosti prodejní tým
apps/erpnext/erpnext/accounts/page/pos/pos.js +1331,Delete permanently?,Zmazať trvalo?
DocType: Expense Claim,Total Claimed Amount,Celkem žalované částky
apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potenciální příležitosti pro prodej.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Neplatný {0}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +59,Sick Leave,Zdravotní dovolená
DocType: Email Digest,Email Digest,Email Digest
DocType: Delivery Note,Billing Address Name,Názov fakturačnej adresy
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +22,Department Stores,Obchodní domy
,Item Delivery Date,Dátum dodania položky
DocType: Warehouse,PIN,PIN
apps/erpnext/erpnext/setup/setup_wizard/sample_data.py +108,Setup your School in ERPNext,Nastavte si škola v ERPNext
DocType: Sales Invoice,Base Change Amount (Company Currency),Základňa Zmena Suma (Company mena)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Žádné účetní záznamy pro následující sklady
apps/erpnext/erpnext/projects/doctype/project/project.js +109,Save the document first.,Uložte dokument ako prvý.
DocType: Account,Chargeable,Vyměřovací
DocType: Company,Change Abbreviation,Zmeniť skratku
DocType: Expense Claim Detail,Expense Date,Datum výdaje
DocType: Item,Max Discount (%),Max zľava (%)
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Suma poslednej objednávky
DocType: Task,Is Milestone,Je míľnikom
DocType: Daily Work Summary,Email Sent To,E-mailom odoslaným
DocType: Budget,Warn,Varovat
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Akékoľvek iné poznámky, pozoruhodné úsilie, ktoré by mali ísť v záznamoch."
DocType: BOM,Manufacturing User,Používateľ výroby
DocType: Purchase Invoice,Raw Materials Supplied,Dodává suroviny
DocType: Purchase Invoice,Recurring Print Format,Opakujúce Print Format
DocType: C-Form,Series,Série
DocType: Appraisal,Appraisal Template,Posouzení Template
DocType: Item Group,Item Classification,Položka Klasifikace
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +100,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 +16,Period,Obdobie
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Hlavná Účtovná Kniha
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Zamestnancov {0} na dovolenke z {1}
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Zobraziť Obchodné iniciatívy
DocType: Program Enrollment Tool,New Program,nový program
DocType: Item Attribute Value,Attribute Value,Hodnota atributu
,Itemwise Recommended Reorder Level,Itemwise Doporučené Změna pořadí Level
DocType: Salary Detail,Salary Detail,plat Detail
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1015,Please select {0} first,"Prosím, najprv vyberte {0}"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +803,Batch {0} of Item {1} has expired.,Batch {0} z {1} bodu vypršala.
DocType: Sales Invoice,Commission,Provize
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Čas list pre výrobu.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,medzisúčet
DocType: Salary Detail,Default Amount,Výchozí částka
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Sklad nebyl nalezen v systému
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,This Month's Summary,Tento mesiac je zhrnutie
DocType: Quality Inspection Reading,Quality Inspection Reading,Kvalita Kontrola Reading
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +24,`Freeze Stocks Older Than` should be smaller than %d days.,`Zmraziť zásoby staršie ako` malo by byť menšie než %d dní.
DocType: Tax Rule,Purchase Tax Template,Spotrebná daň šablóny
,Project wise Stock Tracking,Sledování zboží dle projektu
DocType: GST HSN Code,Regional,regionálne
DocType: Stock Entry Detail,Actual Qty (at source/target),Skutečné množství (u zdroje/cíle)
DocType: Item Customer Detail,Ref Code,Ref Code
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +66,Customer Group is Required in POS Profile,Zákaznícka skupina je povinná v POS profile
apps/erpnext/erpnext/config/hr.py +12,Employee records.,Zamestnanecké záznamy
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +92,Please set Next Depreciation Date,"Prosím, stojí vedľa odpisov Dátum"
DocType: HR Settings,Payroll Settings,Nastavení Mzdové
apps/erpnext/erpnext/config/accounts.py +148,Match non-linked Invoices and Payments.,Zápas Nepropojený fakturách a platbách.
apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Objednať
DocType: Email Digest,New Purchase Orders,Nové vydané objednávky
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Root nemůže mít rodič nákladové středisko
apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Zvoľte značku ...
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Tréningové udalosti / výsledky
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Accumulated Depreciation as on,Oprávky aj na
DocType: Sales Invoice,C-Form Applicable,C-Form Použitelné
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +398,Operation Time must be greater than 0 for Operation {0},Prevádzková doba musí byť väčšia ako 0 pre prevádzku {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,Sklad je povinné
DocType: Supplier,Address and Contacts,Adresa a kontakty
DocType: UOM Conversion Detail,UOM Conversion Detail,Detail konverzie MJ
DocType: Program,Program Abbreviation,program Skratka
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +386,Production Order cannot be raised against a Item Template,Výrobná zákazka nemôže byť vznesená proti šablóny položky
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Poplatky jsou aktualizovány v dokladu o koupi na každou položku
DocType: Warranty Claim,Resolved By,Vyřešena
DocType: Bank Guarantee,Start Date,Dátum začiatku
apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Přidělit listy dobu.
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Šeky a Vklady nesprávne vymazané
apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: You can not assign itself as parent account,Účet {0}: nelze přiřadit sebe jako nadřazený účet
DocType: Purchase Invoice Item,Price List Rate,Cenníková cena
apps/erpnext/erpnext/utilities/activation.py +70,Create customer quotes,Vytvoriť zákaznícke ponuky
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Zobrazit ""Skladem"" nebo ""Není skladem"" na základě skladem k dispozici v tomto skladu."
apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Bill of Materials (BOM)
DocType: Item,Average time taken by the supplier to deliver,Priemerná doba zhotovená dodávateľom dodať
apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.js +22,Assessment Result,hodnotenie výsledkov
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Hodiny
DocType: Project,Expected Start Date,Očekávané datum zahájení
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Odebrat pokud poplatků není pro tuto položku
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,Mena transakcie musí byť rovnaká ako platobná brána menu
DocType: Payment Entry,Receive,Príjem
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Ponuky:
DocType: Maintenance Visit,Fully Completed,Plně Dokončeno
DocType: POS Profile,New Customer Details,Podrobnosti o novom zákazníkovi
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: Budget,Action if Accumulated Monthly Budget Exceeded,Akčný ak súhrnné mesačný rozpočet prekročený
DocType: Purchase Invoice,Submit on creation,Potvrdiť pri vytvorení
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +466,Currency for {0} must be {1},Mena pre {0} musí byť {1}
DocType: Asset,Disposal Date,Likvidácia Dátum
DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","E-maily budú zaslané všetkým aktívnym zamestnancom spoločnosti v danú hodinu, ak nemajú dovolenku. Zhrnutie odpovedí budú zaslané do polnoci."
DocType: Employee Leave Approver,Employee Leave Approver,Schvalujúci priepustiek zamestnanca
apps/erpnext/erpnext/stock/doctype/item/item.py +494,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 +81,"Cannot declare as lost, because Quotation has been made.","Nelze prohlásit za ztracený, protože citace byla provedena."
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +13,Training Feedback,tréning Feedback
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +458,Production Order {0} must be submitted,Výrobní zakázka {0} musí být předloženy
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Kritériá hodnotiacej tabuľky dodávateľa
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},"Prosím, vyberte Počáteční datum a koncové datum pro položku {0}"
apps/erpnext/erpnext/public/js/setup_wizard.js +226,Set a sales target you'd like to achieve.,"Nastavte cieľ predaja, ktorý chcete dosiahnuť."
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Samozrejme je povinné v rade {0}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,K dnešnímu dni nemůže být dříve od data
DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DOCTYPE
apps/erpnext/erpnext/stock/doctype/item/item.js +258,Add / Edit Prices,Pridať / Upraviť ceny
DocType: Batch,Parent Batch,Rodičovská dávka
DocType: Batch,Parent Batch,Rodičovská dávka
DocType: Cheque Print Template,Cheque Print Template,Šek šablóny tlače
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Diagram nákladových středisek
,Requested Items To Be Ordered,Požadované položky je třeba objednat
DocType: Price List,Price List Name,Názov cenníka
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Každodennú prácu Zhrnutie pre {0}
DocType: Employee Loan,Totals,Súčty
DocType: BOM,Manufacturing,Výroba
,Ordered Items To Be Delivered,"Objednané zboží, které mají být dodány"
DocType: Account,Income,Příjem
DocType: Industry Type,Industry Type,Typ Průmyslu
apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Niečo sa pokazilo!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +124,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 +266,Sales Invoice {0} has already been submitted,Predajná faktúra {0} už bola odoslaná
DocType: Supplier Scorecard Scoring Criteria,Score,skóre
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Fiškálny rok {0} neexistuje
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/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Platné do dátumu nemôže byť pred dátumom transakcie
apps/erpnext/erpnext/stock/stock_ledger.py +372,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} jednotiek {1} potrebná {2} o {3} {4} na {5} pre dokončenie tejto transakcie.
DocType: Fee Structure,Student Category,študent Kategórie
DocType: Announcement,Student,študent
apps/erpnext/erpnext/config/hr.py +229,Organization unit (department) master.,Organizace jednotka (departement) master.
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,"Prosím, zadejte zprávu před odesláním"
DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLIKÁT PRE DODÁVATEĽA
DocType: Email Digest,Pending Quotations,Čakajúce ponuky
apps/erpnext/erpnext/config/accounts.py +315,Point-of-Sale Profile,Point-of-Sale Profil
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Nezajištěných úvěrů
DocType: Cost Center,Cost Center Name,Meno nákladového strediska
DocType: Employee,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Maximálna pracovná doba proti časového rozvrhu
DocType: Maintenance Schedule Detail,Scheduled Date,Plánované datum
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77,Total Paid Amt,Celkem uhrazeno Amt
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
,GST Itemised Sales Register,GST Podrobný predajný register
,Serial No Service Contract Expiry,Pořadové číslo Servisní smlouva vypršení platnosti
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Nemůžete dělat kreditní a debetní záznam na stejný účet ve stejnou dobu.
DocType: Naming Series,Help HTML,Nápoveda HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Študent Group Tool Creation
DocType: Item,Variant Based On,Variant založená na
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Celková weightage přiřazen by měla být 100%. Je {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +276,Your Suppliers,Vaši Dodávatelia
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,"Nelze nastavit jako Ztraceno, protože je přijata objednávka."
DocType: Request for Quotation Item,Supplier Part No,Žiadny dodávateľ Part
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +365,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',"Nemôže odpočítať, ak kategória je pre &quot;ocenenie&quot; alebo &quot;Vaulation a Total&quot;"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +360,Received From,Prijaté Od
DocType: Lead,Converted,Převedené
DocType: Item,Has Serial No,Má Sériové číslo
DocType: Employee,Date of Issue,Datum vydání
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +24,{0}: From {0} for {1},{0}: Od {0} do {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +218,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Podľa Nákupných nastavení, ak je potrebná nákupná požiadavka == &#39;ÁNO&#39;, potom pre vytvorenie nákupnej faktúry musí používateľ najskôr vytvoriť potvrdenie nákupu pre položku {0}"
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +166,Row #{0}: Set Supplier for item {1},Riadok # {0}: Nastavte Dodávateľ pre položku {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Riadok {0}: doba hodnota musí byť väčšia ako nula.
apps/erpnext/erpnext/stock/doctype/item/item.py +171,Website Image {0} attached to Item {1} cannot be found,Webové stránky Image {0} pripája k bodu {1} nemožno nájsť
DocType: Issue,Content Type,Typ obsahu
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,Počítač
DocType: Item,List this Item in multiple groups on the website.,Seznam tuto položku ve více skupinách na internetových stránkách.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,"Prosím, skontrolujte viac mien možnosť povoliť účty s inú menu"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +89,Item: {0} does not exist in the system,Položka: {0} neexistuje v systému
apps/erpnext/erpnext/accounts/doctype/account/account.py +109,You are not authorized to set Frozen value,Nejste oprávněni stanovit hodnotu Zmražení
DocType: Payment Reconciliation,Get Unreconciled Entries,Získat smířit záznamů
DocType: Payment Reconciliation,From Invoice Date,Z faktúry Dátum
apps/erpnext/erpnext/accounts/party.py +261,Billing currency must be equal to either default comapany's currency or party account currency,Fakturačná mena sa musí rovnať meny alebo účtu strana peňazí buď predvoleného comapany je
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +44,Leave Encashment,nechať inkasa
apps/erpnext/erpnext/public/js/setup_wizard.js +96,What does it do?,Čím sa zaoberá?
apps/erpnext/erpnext/stock/doctype/batch/batch.js +70,To Warehouse,Do skladu
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +23,All Student Admissions,Všetky Študent Prijímacie
,Average Commission Rate,Průměrná cena Komise
apps/erpnext/erpnext/stock/doctype/item/item.py +406,'Has Serial No' can not be 'Yes' for non-stock item,"""Má sériové číslo"", nemôže byť ""áno"" pre neskladový tovar"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Účast nemůže být označen pro budoucí data
DocType: Pricing Rule,Pricing Rule Help,Ceny Pravidlo Help
DocType: School House,House Name,Meno dom
DocType: Purchase Taxes and Charges,Account Head,Účet Head
apps/erpnext/erpnext/config/stock.py +168,Update additional costs to calculate landed cost of items,Aktualizace dodatečné náklady pro výpočet vyložené náklady položek
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +122,Electrical,Elektrický
apps/erpnext/erpnext/utilities/activation.py +98,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Pridajte ostatných z vašej organizácie ako používateľov. Môžete tiež pridať a pozvať zákazníkov na portál ich pridaním zo zoznamu kontaktov
DocType: Stock Entry,Total Value Difference (Out - In),Celková hodnota Rozdíl (Out - In)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Riadok {0}: Exchange Rate je povinné
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},User ID není nastavena pro zaměstnance {0}
DocType: Vehicle,Vehicle Value,hodnota vozidla
DocType: 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 +216,Birthday Reminder for {0},Narozeninová připomínka pro {0}
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Počet dnů od poslední objednávky
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +353,Debit To account must be a Balance Sheet account,Debetné Na účet musí byť účtu Súvaha
DocType: Buying Settings,Naming Series,Číselné rady
DocType: Leave Block List,Leave Block List Name,Nechte Jméno Block List
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Dátum poistenie štarte by mala byť menšia ako poistenie koncovým dátumom
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Stock Aktiva
DocType: Timesheet,Production Detail,výroba Detail
DocType: Target Detail,Target Qty,Target Množství
DocType: Shopping Cart Settings,Checkout Settings,pokladňa Nastavenie
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
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Záverečný účet {0} musí byť typu zodpovednosti / Equity
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +323,Salary Slip of employee {0} already created for time sheet {1},Výplatnej páske zamestnanca {0} už vytvorili pre časové list {1}
DocType: Vehicle Log,Odometer,Počítadlo najazdených kilometrov
DocType: Sales Order Item,Ordered Qty,Objednáno Množství
apps/erpnext/erpnext/stock/doctype/item/item.py +677,Item {0} is disabled,Položka {0} je zakázaná
DocType: Stock Settings,Stock Frozen Upto,Reklamní Frozen aľ
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +895,BOM does not contain any stock item,BOM neobsahuje žiadnu skladovú položku
apps/erpnext/erpnext/controllers/recurring_document.py +172,Period From and Period To dates mandatory for recurring {0},"Dátumy od a do, sú povinné pre opakovanie {0}"
apps/erpnext/erpnext/config/projects.py +18,Project activity / task.,Projektová činnost / úkol.
DocType: Vehicle Log,Refuelling Details,tankovacie Podrobnosti
apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Generování výplatních páskách
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"Buying must be checked, if Applicable For is selected as {0}","Nákup musí být zkontrolováno, v případě potřeby pro vybrán jako {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Sleva musí být menší než 100
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +121,Last purchase rate not found,Posledná nákupná  cena nenájdená
DocType: Purchase Invoice,Write Off Amount (Company Currency),Odpísať Suma (Company meny)
DocType: Sales Invoice Timesheet,Billing Hours,billing Hodiny
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +499,Default BOM for {0} not found,Predvolené BOM pre {0} nebol nájdený
apps/erpnext/erpnext/stock/doctype/item/item.py +486,Row #{0}: Please set reorder quantity,Riadok # {0}: Prosím nastavte množstvo objednávacie
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Poklepte na položky a pridajte ich sem
DocType: Fees,Program Enrollment,Registrácia do programu
DocType: Landed Cost Voucher,Landed Cost Voucher,Přistálo Náklady Voucher
apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Prosím nastavte {0}
DocType: Purchase Invoice,Repeat on Day of Month,Opakujte na den v měsíci
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +36,{0} - {1} is inactive student,{0} - {1} je neaktívnym študentom
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +36,{0} - {1} is inactive student,{0} - {1} je neaktívnym študentom
DocType: Employee,Health Details,Zdravotní Podrobnosti
DocType: Offer Letter,Offer Letter Terms,Ponuka Letter Podmienky
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Vyžaduje sa vytvorenie referenčného dokumentu žiadosti o platbu
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,Vyžaduje sa vytvorenie referenčného dokumentu žiadosti o platbu
DocType: Payment Entry,Allocate Payment Amount,Vyčleniť sumu platby
DocType: Employee External Work History,Salary,Plat
DocType: Serial No,Delivery Document Type,Dodávka Typ dokumentu
DocType: Process Payroll,Submit all salary slips for the above selected criteria,Odeslat všechny výplatní pásky pro výše zvolených kritérií
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +93,{0} Items synced,{0} položky synchronizované
DocType: Sales Order,Partly Delivered,Částečně vyhlášeno
DocType: Email Digest,Receivables,Pohledávky
DocType: Lead Source,Lead Source,Zdroj Iniciatívy
DocType: Customer,Additional information regarding the customer.,Ďalšie informácie týkajúce sa zákazníka.
DocType: Quality Inspection Reading,Reading 5,Čtení 5
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +221,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} je priradená ku {2}, ale účet Party je {3}"
DocType: Purchase Invoice,Y,Y
DocType: Maintenance Visit,Maintenance Date,Datum údržby
DocType: Purchase Invoice Item,Rejected Serial No,Zamítnuto Serial No
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,Rok dátum začatia alebo ukončenia sa prekrýva s {0}. Aby sa zabránilo nastavte firmu
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},Datum zahájení by měla být menší než konečné datum pro bod {0}
DocType: Item,"Example: ABCD.#####
If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Příklad:. ABCD ##### 
 Je-li série nastavuje a pořadové číslo není uvedeno v transakcích, bude vytvořen poté automaticky sériové číslo na základě této série. Pokud chcete vždy výslovně uvést pořadová čísla pro tuto položku. ponechte prázdné."
DocType: Upload Attendance,Upload Attendance,Nahráť Dochádzku
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +319,BOM and Manufacturing Quantity are required,BOM a Výrobné množstvo sú povinné
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Stárnutí rozsah 2
DocType: SG Creation Tool Course,Max Strength,Max Sila
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,BOM nahradil
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +982,Select Items based on Delivery Date,Vyberte položku podľa dátumu doručenia
,Sales Analytics,Analýza predaja
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +114,Available {0},K dispozícii {0}
,Prospects Engaged But Not Converted,"Perspektívy zapojené, ale nekonvertované"
,Prospects Engaged But Not Converted,"Perspektívy zapojené, ale nekonvertované"
DocType: Manufacturing Settings,Manufacturing Settings,Nastavenia Výroby
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Nastavenia pre e-mail
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,Guardian1 Mobile Žiadne
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +102,Please enter default currency in Company Master,Zadejte prosím výchozí měnu v podniku Mistr
DocType: Stock Entry Detail,Stock Entry Detail,Detail pohybu zásob
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Daily Reminders,Denná Upomienky
DocType: Products Settings,Home Page is Products,Domovskou stránkou je stránka Produkty.
,Asset Depreciation Ledger,Asset Odpisy Ledger
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +87,Tax Rule Conflicts with {0},Daňové Pravidlo Konflikty s {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Nový názov účtu
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Dodává se nákladů na suroviny
DocType: Selling Settings,Settings for Selling Module,Nastavenie modulu Predaj
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +84,Customer Service,Služby zákazníkům
DocType: BOM,Thumbnail,Thumbnail
DocType: Item Customer Detail,Item Customer Detail,Položka Detail Zákazník
apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Ponuka kandidát Job.
DocType: Notification Control,Prompt for Email on Submission of,Výzva pro e-mail na předkládání
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Celkové pridelené listy sú viac ako dní v období
DocType: Pricing Rule,Percentage,percento
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Položka {0} musí být skladem
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Východiskové prácu v sklade Progress
apps/erpnext/erpnext/config/accounts.py +290,Default settings for accounting transactions.,Výchozí nastavení účetních transakcí.
DocType: Maintenance Visit,MV,MV
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +59,Expected Date cannot be before Material Request Date,Očekávané datum nemůže být před Materiál Poptávka Datum
DocType: Purchase Invoice Item,Stock Qty,Množstvo zásob
DocType: Purchase Invoice Item,Stock Qty,Množstvo zásob
DocType: Employee Loan,Repayment Period in Months,Doba splácania v mesiacoch
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Chyba: Nie je platný id?
DocType: Naming Series,Update Series Number,Aktualizace Series Number
DocType: Account,Equity,Hodnota majetku
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: &quot;výkaz ziskov a strát&quot; typ účtu {2} nie je povolený vstup do Otváracia Entry
DocType: Sales Order,Printing Details,Detaily tlače
DocType: Task,Closing Date,Uzávěrka Datum
DocType: Sales Order Item,Produced Quantity,Vyrobené Množstvo
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +95,Engineer,Inženýr
DocType: Journal Entry,Total Amount Currency,Celková suma Mena
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Vyhľadávanie Sub Assemblies
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +167,Item Code required at Row No {0},Kód položky třeba na řádku č {0}
DocType: Sales Partner,Partner Type,Partner Type
DocType: Purchase Taxes and Charges,Actual,Aktuální
DocType: Authorization Rule,Customerwise Discount,Sleva podle zákazníka
apps/erpnext/erpnext/config/projects.py +40,Timesheet for tasks.,Časového rozvrhu pre úlohy.
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 +273,Installation Note {0} has already been submitted,Poznámka k instalaci {0} již byla odeslána
DocType: Bank Reconciliation,Get Payment Entries,Získať Platobné položky
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."
apps/erpnext/erpnext/projects/doctype/project/project.js +62,Gantt Chart,Pruhový diagram
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +68,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 +59,Series Updated,Řada Aktualizováno
apps/erpnext/erpnext/accounts/doctype/account/account.py +162,Report Type is mandatory,Report Type je povinné
DocType: Item,Serial Number Series,Sériové číslo Series
apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Sklad je povinný pro skladovou položku {0} na řádku {1}
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +45,Retail & Wholesale,Maloobchod a velkoobchod
DocType: Issue,First Responded On,Prvně odpovězeno dne
DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Výpis zboží v několika skupinách
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Datum zahájení a  Datum ukončení Fiskálního roku jsou již stanoveny ve fiskálním roce {0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Svetlá Dátum aktualizované
apps/erpnext/erpnext/stock/doctype/batch/batch.js +126,Split Batch,Split Batch
apps/erpnext/erpnext/stock/doctype/batch/batch.js +126,Split Batch,Split Batch
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Úspešne zinventarizované
DocType: Request for Quotation Supplier,Download PDF,Stiahnuť PDF
DocType: Production Order,Planned End Date,Plánované datum ukončení
apps/erpnext/erpnext/config/stock.py +184,Where items are stored.,"Tam, kde jsou uloženy předměty."
DocType: Request for Quotation,Supplier Detail,Detail dodávateľa
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Error in formula or condition: {0},Chyba vo vzorci alebo stave: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Fakturovaná čiastka
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Kritériové váhy musia pripočítať až 100%
DocType: Attendance,Attendance,Účast
apps/erpnext/erpnext/public/js/pos/pos.html +106,Stock Items,Položky zásob
DocType: BOM,Materials,Materiály
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Pokud není zatrženo, seznam bude muset být přidány ke každé oddělení, kde má být použit."
apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Zdrojové a cieľové skladov nemôžu byť rovnaké
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +535,Posting date and posting time is mandatory,Datum a čas zadání je povinný
apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Daňové šablona pro nákup transakcí.
,Item Prices,Ceny Položek
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,"Ve slovech budou viditelné, jakmile uložíte objednávce."
DocType: Period Closing Voucher,Period Closing Voucher,Období Uzávěrka Voucher
apps/erpnext/erpnext/config/selling.py +67,Price List master.,Ceník master.
DocType: Task,Review Date,Review Datum
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Séria pre odpisy majetku (záznam v účte)
DocType: Purchase Invoice,Advance Payments,Zálohové platby
DocType: Purchase Taxes and Charges,On Net Total,On Net Celkem
apps/erpnext/erpnext/controllers/item_variant.py +90,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Hodnota atribútu {0} musí byť v rozmedzí od {1} až {2} v krokoch po {3} pre item {4}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +161,Target warehouse in row {0} must be same as Production Order,Target sklad v řádku {0} musí být stejná jako výrobní zakázky
apps/erpnext/erpnext/controllers/recurring_document.py +217,'Notification Email Addresses' not specified for recurring %s,"""E-mailové adresy pre upozornenie"" nie sú uvedené pre opakujúce sa %s"
apps/erpnext/erpnext/accounts/doctype/account/account.py +127,Currency can not be changed after making entries using some other currency,Mena nemôže byť zmenený po vykonaní položky pomocou inej mene
DocType: Vehicle Service,Clutch Plate,kotúč spojky
DocType: Company,Round Off Account,Zaokrúhliť účet
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Administrativní náklady
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,Consulting
DocType: Customer Group,Parent Customer Group,Parent Customer Group
DocType: Purchase Invoice,Contact Email,Kontaktní e-mail
DocType: Appraisal Goal,Score Earned,Skóre Zasloužené
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +202,Notice Period,Výpovedná Lehota
DocType: Asset Category,Asset Category Name,Asset názov kategórie
apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,To je kořen území a nelze upravovat.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Meno Nová Sales Osoba
DocType: Packing Slip,Gross Weight UOM,Hrubá Hmotnosť MJ
DocType: Delivery Note Item,Against Sales Invoice,Proti prodejní faktuře
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +122,Please enter serial numbers for serialized item ,Zadajte sériové čísla pre sériovú položku
DocType: Bin,Reserved Qty for Production,Vyhradené Množstvo pre výrobu
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Ponechajte nezačiarknuté, ak nechcete zohľadňovať dávku pri zaradení do skupín."
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,"Ponechajte nezačiarknuté, ak nechcete zohľadňovať dávku pri zaradení do skupín."
DocType: Asset,Frequency of Depreciation (Months),Frekvencia odpisy (mesiace)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +493,Credit Account,Úverový účet
DocType: Landed Cost Item,Landed Cost Item,Přistálo nákladovou položkou
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Ukázat nulové hodnoty
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Množství položky získané po výrobě / přebalení z daných množství surovin
apps/erpnext/erpnext/public/js/setup_wizard.js +397,Setup a simple website for my organization,Nastavenie jednoduché webové stránky pre moju organizáciu
DocType: Payment Reconciliation,Receivable / Payable Account,Pohledávky / závazky účet
DocType: Delivery Note Item,Against Sales Order Item,Proti položce přijaté objednávky
apps/erpnext/erpnext/stock/doctype/item/item.py +644,Please specify Attribute Value for attribute {0},Uveďte atribútu Hodnota atribútu {0}
DocType: Item,Default Warehouse,Výchozí Warehouse
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Rozpočet nemôže byť priradená na skupinový účet {0}
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,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/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,odpisy Dátum
DocType: Issue,Support Team,Tým podpory
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Doba použiteľnosti (v dňoch)
DocType: Appraisal,Total Score (Out of 5),Celkové skóre (Out of 5)
DocType: Fee Structure,FS.,FS.
DocType: Student Attendance Tool,Batch,Šarža
apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Zostatok
DocType: Room,Seating Capacity,Počet miest na sedenie
DocType: Issue,ISS-,ISS-
DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Claim (via Expense nárokov)
DocType: GST Settings,GST Summary,Súhrn GST
DocType: Assessment Result,Total Score,Konečné skóre
DocType: Journal Entry,Debit Note,Debit Note
DocType: Stock Entry,As per Stock UOM,Podľa skladovej MJ
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Neuplynula
DocType: Student Log,Achievement,úspech
DocType: Batch,Source Document Type,Zdrojový typ dokumentu
DocType: Journal Entry,Total Debit,Celkem Debit
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Východzí hotových výrobkov Warehouse
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +78,Sales Person,Predajca
apps/erpnext/erpnext/config/accounts.py +235,Budget and Cost Center,Rozpočet a nákladového strediska
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +60,Multiple default mode of payment is not allowed,Nie je povolený viacnásobný predvolený spôsob platby
DocType: Vehicle Service,Half Yearly,Polročne
DocType: Lead,Blog Subscriber,Blog Subscriber
DocType: Guardian,Alternate Number,Alternatívne Number
DocType: Assessment Plan Criteria,Maximum Score,maximálny počet bodov
apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Vytvoření pravidla pro omezení transakce na základě hodnot.
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Skupina Roll Nie
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Nechajte prázdne, ak robíte študentské skupiny ročne"
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,"Nechajte prázdne, ak robíte študentské skupiny ročne"
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/schools/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Termínovaný Dátum ukončenia nesmie byť starší ako Počiatočný dátum doby platnosti. Opravte dáta a skúste to znova.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Počet kvót
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Počet kvót
,BOM Stock Report,BOM Reklamné Report
DocType: Stock Reconciliation Item,Quantity Difference,Množstvo Rozdiel
apps/erpnext/erpnext/config/hr.py +311,Processing Payroll,Spracovanie miezd
DocType: Opportunity Item,Basic Rate,Základná sadzba
DocType: GL Entry,Credit Amount,Výška úveru
DocType: Cheque Print Template,Signatory Position,signatár Position
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Set as Lost,Nastaviť ako Nezískané
DocType: Timesheet,Total Billable Hours,Celkom zúčtovateľnej hodiny
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Doklad o zaplatení Note
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,To je založené na transakciách proti tomuto zákazníkovi. Pozri časovú os nižšie podrobnosti
DocType: Supplier,Credit Days Based On,Úverové Dni Based On
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Riadok {0}: Pridelená suma {1} musí byť menší ako alebo sa rovná sume zaplatení výstavného {2}
,Course wise Assessment Report,Priebežná hodnotiaca správa
DocType: Tax Rule,Tax Rule,Daňové Pravidlo
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Udržovat stejná sazba po celou dobu prodejního cyklu
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Naplánujte čas protokoly mimo Workstation pracovných hodín.
apps/erpnext/erpnext/public/js/pos/pos.html +89,Customers in Queue,Zákazníci vo fronte
DocType: Student,Nationality,národnosť
,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,Informácie o spoločnosti
apps/erpnext/erpnext/accounts/page/pos/pos.js +1363,Select or add new customer,Vyberte alebo pridajte nového zákazníka
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +154,Cost center is required to book an expense claim,Nákladové stredisko je nutné rezervovať výdavkov nárok
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Aplikace fondů (aktiv)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,To je založené na účasti základu tohto zamestnanca
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Označenie účasti
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +487,Debit Account,Debetné účet
DocType: Fiscal Year,Year Start Date,Dátom začiatku roka
DocType: Attendance,Employee Name,Meno zamestnanca
DocType: Sales Invoice,Rounded Total (Company Currency),Zaoblený Total (Company Měna)
apps/erpnext/erpnext/accounts/doctype/account/account.py +99,Cannot covert to Group because Account Type is selected.,"Nelze skryté do skupiny, protože je požadovaný typ účtu."
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +240,{0} {1} has been modified. Please refresh.,{0} {1} bol zmenený. Prosím aktualizujte.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Přestaňte uživatelům provádět Nechat aplikací v následujících dnech.
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,suma nákupu
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +259,Supplier Quotation {0} created,Dodávateľ Cien {0} vytvoril
apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Koniec roka nemôže byť pred uvedením do prevádzky roku
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +195,Employee Benefits,Zamestnanecké benefity
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packed quantity must equal quantity for Item {0} in row {1},Balené množstvo se musí rovnať množstvu pre položku {0} v riadku {1}
DocType: Production Order,Manufactured Qty,Vyrobeno Množství
DocType: Purchase Receipt Item,Accepted Quantity,Schválené Množstvo
apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Please set a default Holiday List for Employee {0} or Company {1},Prosím nastaviť predvolené Holiday List pre zamestnancov {0} alebo {1} Company
apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0}: {1} neexistuje
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +74,Select Batch Numbers,Vyberte dávkové čísla
apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Faktúry zákazníkom
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID projektu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},"Riadok č {0}: Čiastka nemôže byť väčšia ako Čakajúci Suma proti Expense nároku {1}. Do doby, než množstvo je {2}"
DocType: Maintenance Schedule,Schedule,Plán
DocType: Account,Parent Account,Nadřazený účet
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +232,Available,K dispozici
DocType: Quality Inspection Reading,Reading 3,Čtení 3
,Hub,Hub
DocType: GL Entry,Voucher Type,Voucher Type
apps/erpnext/erpnext/accounts/page/pos/pos.js +1655,Price List not found or disabled,Ceník nebyl nalezen nebo zakázán
DocType: Employee Loan Application,Approved,Schválený
DocType: Pricing Rule,Price,Cena
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +264,Employee relieved on {0} must be set as 'Left',"Zamestnanec uvoľnený na {0} musí byť nastavený ako ""Opustil"""
DocType: Guardian,Guardian,poručník
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Posouzení {0} vytvořil pro zaměstnance {1} v daném časovém období
DocType: Employee,Education,Vzdelanie
apps/erpnext/erpnext/public/js/pos/pos.html +80,Del,del
DocType: Selling Settings,Campaign Naming By,Kampaň Pojmenování By
DocType: Employee,Current Address Is,Aktuálna adresa je
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modifikovaný
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +41,"Optional. Sets company's default currency, if not specified.","Voliteľné. Nastaví východiskovej mene spoločnosti, ak nie je uvedené."
DocType: Sales Invoice,Customer GSTIN,Zákazník GSTIN
apps/erpnext/erpnext/config/accounts.py +61,Accounting journal entries.,Zápisy v účetním deníku.
DocType: Delivery Note Item,Available Qty at From Warehouse,K dispozícii Množstvo na Od Warehouse
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,"Prosím, vyberte zamestnanca záznam prvý."
DocType: POS Profile,Account for Change Amount,Účet pre zmenu Suma
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Riadok {0}: Party / Account nezhoduje s {1} / {2} do {3} {4}
apps/erpnext/erpnext/schools/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Kód kurzu:
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,"Prosím, zadejte výdajového účtu"
DocType: Account,Stock,Sklad
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1040,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Riadok # {0}: Reference Document Type musí byť jedným z objednávky, faktúry alebo Journal Entry"
DocType: Employee,Current Address,Aktuálna 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: Assessment Group,Assessment Group,skupina Assessment
apps/erpnext/erpnext/config/stock.py +320,Batch Inventory,Batch Zásoby
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
DocType: Sales Invoice Item,Discount and Margin,Zľava a Margin
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: Pricing Rule,Min Qty,Min Množství
DocType: Asset Movement,Transaction Date,Transakce Datum
DocType: Production Plan Item,Planned Qty,Plánované Množství
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total Tax
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177,For Quantity (Manufactured Qty) is mandatory,Pre Množstvo (Vyrobené ks) je povinné
DocType: Stock Entry,Default Target Warehouse,Výchozí Target Warehouse
DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Company Měna)
apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Rok Dátum ukončenia nesmie byť starší ako dátum rok Štart. Opravte dáta a skúste to znova.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Riadok {0}: Typ Party Party a je použiteľná len proti pohľadávky / záväzky účtu
DocType: Notification Control,Purchase Receipt Message,Správa o príjemke
DocType: BOM,Scrap Items,šrot položky
DocType: Production Order,Actual Start Date,Skutečné datum zahájení
DocType: Sales Order,% of materials delivered against this Sales Order,% materiálov dodaných proti tejto Predajnej objednávke
apps/erpnext/erpnext/config/stock.py +12,Record item movement.,Záznam pohybu položka.
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +57,Set default mode of payment,Nastavte predvolený spôsob platby
DocType: Training Event Employee,Withdrawn,uzavretý
DocType: Hub Settings,Hub Settings,Nastavení Hub
DocType: Project,Gross Margin %,Hrubá Marža %
DocType: BOM,With Operations,S operacemi
apps/erpnext/erpnext/accounts/party.py +257,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,"Položky účtovníctva už boli vykonané v mene, {0} pre firmu {1}. Vyberte pohľadávky a záväzku účet s menou {0}."
DocType: Asset,Is Existing Asset,Je existujúcemu aktívu
DocType: Salary Detail,Statistical Component,Štatistická zložka
DocType: Warranty Claim,If different than customer address,Pokud se liší od adresy zákazníka
DocType: Purchase Invoice,Without Payment of Tax,Bez platenia dane
DocType: BOM Operation,BOM Operation,BOM Operation
DocType: Purchase Taxes and Charges,On Previous Row Amount,Na předchozí řady Částka
DocType: Student,Home Address,Adresa bydliska
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +260,Transfer Asset,prevod majetku
DocType: POS Profile,POS Profile,POS Profile
DocType: Training Event,Event Name,Názov udalosti
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +10,Admission,vstupné
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +26,Admissions for {0},Prijímacie konanie pre {0}
apps/erpnext/erpnext/config/accounts.py +259,"Seasonality for setting budgets, targets etc.","Sezónnost pro nastavení rozpočtů, cíle atd."
DocType: Supplier Scorecard Scoring Variable,Variable Name,Názov premennej
apps/erpnext/erpnext/stock/get_item_details.py +147,"Item {0} is a template, please select one of its variants","Položka {0} je šablóna, prosím vyberte jednu z jeho variantov"
DocType: Asset,Asset Category,asset Kategórie
apps/erpnext/erpnext/public/js/setup_wizard.js +213,Purchaser,Nákupca
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Netto plat nemôže byť záporný
DocType: Assessment Plan,Room,izbu
DocType: Purchase Order,Advance Paid,Vyplacené zálohy
DocType: Item,Item Tax,Daň Položky
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +818,Material to Supplier,Materiál Dodávateľovi
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +384,Excise Invoice,Spotrebný Faktúra
apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Prah {0}% sa objaví viac ako raz
DocType: Expense Claim,Employees Email Id,Zaměstnanci Email Id
DocType: Employee Attendance Tool,Marked Attendance,Výrazná Návštevnosť
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Krátkodobé závazky
apps/erpnext/erpnext/config/selling.py +292,Send mass SMS to your contacts,Posílat hromadné SMS vašim kontaktům
DocType: Program,Program Name,Názov programu
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 +57,Actual Qty is mandatory,Skutočné množstvo je povinné
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +79,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} v súčasnosti má postavenie {1} Scorecardu pre dodávateľov a nákupné objednávky tomuto dodávateľovi by mali byť vydané opatrne.
DocType: Employee Loan,Loan Type,pôžička Type
DocType: Scheduling Tool,Scheduling Tool,plánovanie Tool
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +149,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 +179,Default settings for stock transactions.,Výchozí nastavení pro akciových transakcí.
DocType: Purchase Invoice,Next Date,Ďalší Dátum
DocType: Employee Education,Major/Optional Subjects,Hlavní / Volitelné předměty
DocType: Sales Invoice Item,Drop Ship,Drop Loď
DocType: Training Event,Attendees,Účastníci
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Zde si můžete udržovat rodinné detailů, jako jsou jméno a povolání rodičem, manželem a dětmi"
DocType: Academic Term,Term End Date,Termín Dátum ukončenia
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,Všeobecné nastavenia
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Z měny a měny nemůže být stejné
DocType: Stock Entry,Repack,Přebalit
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Musíte Uložte formulář před pokračováním
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +96,Please select the Company first,Najskôr vyberte spoločnosť
DocType: Item Attribute,Numeric Values,Číselné hodnoty
apps/erpnext/erpnext/public/js/setup_wizard.js +47,Attach Logo,Pripojiť Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js +38,Stock Levels,Úrovne zásob
DocType: Customer,Commission Rate,Výška provízie
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Vytvorili {0} scorecards pre {1} medzi:
apps/erpnext/erpnext/stock/doctype/item/item.js +332,Make Variant,Vytvoriť Variant
apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Aplikace Block dovolené podle oddělení.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +144,"Payment Type must be one of Receive, Pay and Internal Transfer",Typ platby musí byť jedným z príjem Pay a interný prevod
apps/erpnext/erpnext/config/selling.py +179,Analytics,analytika
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +21,Cart is Empty,Košík je prázdny
DocType: Vehicle,Model,Modelka
DocType: Production Order,Actual Operating Cost,Skutečné provozní náklady
DocType: Payment Entry,Cheque/Reference No,Šek / Referenčné číslo
apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root cannot be edited.,Root nelze upravovat.
DocType: Item,Units of Measure,merné jednotky
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 +163,Capital Stock,Základný kapitál
DocType: Shopping Cart Settings,Show Public Attachments,Zobraziť verejné prílohy
DocType: Packing Slip,Package Weight Details,Hmotnost balení Podrobnosti
DocType: Payment Gateway Account,Payment Gateway Account,Platobná brána účet
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Po dokončení platby presmerovať užívateľa na vybrané stránky.
DocType: Company,Existing Company,existujúce Company
apps/erpnext/erpnext/controllers/buying_controller.py +82,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","Daňová kategória bola zmenená na &quot;Celkom&quot;, pretože všetky položky sú položky, ktoré nie sú na sklade"
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Vyberte soubor csv
DocType: Student Leave Application,Mark as Present,Označiť ako prítomný
DocType: Supplier Scorecard,Indicator Color,Farba indikátora
DocType: Purchase Order,To Receive and Bill,Prijímať a Bill
apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Predstavované produkty
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +105,Designer,Návrhář
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Podmínky Template
DocType: Serial No,Delivery Details,Zasílání
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +485,Cost Center is required in row {0} in Taxes table for type {1},Nákladové středisko je nutné v řadě {0} na daních tabulka typu {1}
DocType: Program,Program Code,kód programu
DocType: Terms and Conditions,Terms and Conditions Help,podmienky nápovedy
,Item-wise Purchase Register,Item-moudrý Nákup Register
DocType: Batch,Expiry Date,Datum vypršení platnosti
,accounts-browser,Účty-browser
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +351,Please select Category first,Nejdřív vyberte kategorii
apps/erpnext/erpnext/config/projects.py +13,Project master.,Master Project.
apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Ak chcete povoliť over-fakturáciu alebo over-objednávanie, aktualizujte &quot;príspevok&quot; v Nastavenie sklade, alebo výtlačku."
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Neukazovať žiadny symbol ako $ atď vedľa meny.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +459, (Half Day),(Pól dňa)
DocType: Supplier,Credit Days,Úvěrové dny
apps/erpnext/erpnext/utilities/activation.py +126,Make Student Batch,Urobiť Študent Batch
DocType: Leave Type,Is Carry Forward,Je převádět
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806,Get Items from BOM,Získat předměty z BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Vek Obchodnej iniciatívy v dňoch
apps/erpnext/erpnext/controllers/accounts_controller.py +569,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Riadok # {0}: Vysielanie dátum musí byť rovnaké ako dátum nákupu {1} aktíva {2}
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,"Skontrolujte, či študent býva v hosteli inštitútu."
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +129,Please enter Sales Orders in the above table,"Prosím, zadajte Predajné objednávky v tabuľke vyššie"
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +182,Not Submitted Salary Slips,Nie je Vložené výplatných páskach
,Stock Summary,Sumár zásob
apps/erpnext/erpnext/config/accounts.py +274,Transfer an asset from one warehouse to another,Previesť aktíva z jedného skladu do druhého
DocType: Vehicle,Petrol,benzín
apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Kusovník
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Riadok {0}: Typ Party Party a je nutné pre pohľadávky / záväzky na účte {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref Datum
DocType: Employee,Reason for Leaving,Důvod Leaving
DocType: BOM Operation,Operating Cost(Company Currency),Prevádzkové náklady (Company mena)
DocType: Employee Loan Application,Rate of Interest,úroková sadzba
DocType: Expense Claim Detail,Sanctioned Amount,Sankcionovaná čiastka
DocType: GL Entry,Is Opening,Se otevírá
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Row {0}: záporný nemůže být spojována s {1}
apps/erpnext/erpnext/accounts/doctype/account/account.py +193,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í.
