DocType: Employee,Salary Mode,laun Mode
DocType: Employee,Divorced,skilin
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +96,Items already synced,Atriði þegar samstillt
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Leyfa Atriði til að bæta við mörgum sinnum í viðskiptum
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Hætta Efni Visit {0} áður hætta þessu ábyrgð kröfu
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +19,Consumer Products,Consumer Products
DocType: Item,Customer Items,Atriði viðskiptavina
DocType: Project,Costing and Billing,Kosta og innheimtu
apps/erpnext/erpnext/accounts/doctype/account/account.py +53,Account {0}: Parent account {1} can not be a ledger,Reikningur {0}: Foreldri reikningur {1} getur ekki verið höfuðbók
DocType: Item,Publish Item to hub.erpnext.com,Birta Item til hub.erpnext.com
apps/erpnext/erpnext/config/setup.py +88,Email Notifications,Tilkynningar í tölvupósti
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +22,Evaluation,mat
DocType: Item,Default Unit of Measure,Default Mælieiningin
DocType: SMS Center,All Sales Partner Contact,Allt Sales Partner samband við
DocType: Employee,Leave Approvers,Skildu Approvers
DocType: Sales Partner,Dealer,söluaðila
DocType: Employee,Rented,leigt
DocType: Purchase Order,PO-,PO-
DocType: POS Profile,Applicable for User,Gildir fyrir notanda
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +193,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Hætt framleiðslu Order er ekki hægt að hætt, Unstop það fyrst til að fá ensku"
DocType: Vehicle Service,Mileage,mílufjöldi
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +231,Do you really want to scrap this asset?,Viltu virkilega að skrappa þessa eign?
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +48,Select Default Supplier,Veldu Default Birgir
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Gjaldmiðill er nauðsynlegt til verðlisti {0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Verður að reikna í viðskiptunum.
DocType: Purchase Order,Customer Contact,viðskiptavinur samband við
DocType: Job Applicant,Job Applicant,Atvinna umsækjanda
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Þetta er byggt á viðskiptum móti þessum Birgir. Sjá tímalínu hér fyrir nánari upplýsingar
apps/erpnext/erpnext/hub_node/page/hub/hub_body.html +18,No more results.,Engar fleiri niðurstöður.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +34,Legal,Legal
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +166,Actual type tax cannot be included in Item rate in row {0},Raunveruleg gerð skattur getur ekki verið með í Liður hlutfall í röð {0}
DocType: Bank Guarantee,Customer,viðskiptavinur
DocType: Purchase Receipt Item,Required By,krafist er í
DocType: Delivery Note,Return Against Delivery Note,Aftur gegn afhendingu Note
DocType: Purchase Order,% Billed,% Billed
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Gengi að vera það sama og {0} {1} ({2})
DocType: Sales Invoice,Customer Name,Nafn viðskiptavinar
DocType: Vehicle,Natural Gas,Náttúru gas
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +130,Bank account cannot be named as {0},bankareikningur getur ekki verið nefnt sem {0}
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Höfuð (eða hópar) gegn sem bókhaldsfærslum eru gerðar og jafnvægi er viðhaldið.
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Framúrskarandi fyrir {0} má ekki vera minna en núll ({1})
DocType: Manufacturing Settings,Default 10 mins,Default 10 mínútur
DocType: Leave Type,Leave Type Name,Skildu Tegund Nafn
apps/erpnext/erpnext/templates/pages/projects.js +63,Show open,sýna opinn
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +155,Series Updated Successfully,Series Uppfært Tókst
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Athuga
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +179,Accural Journal Entry Submitted,Accural Journal Entry Lögð
DocType: Pricing Rule,Apply On,gilda um
DocType: Item Price,Multiple Item prices.,Margar Item verð.
,Purchase Order Items To Be Received,Purchase Order Items að berast
DocType: SMS Center,All Supplier Contact,Allt Birgir samband við
DocType: Support Settings,Support Settings,Stuðningur Stillingar
DocType: SMS Parameter,Parameter,Parameter
apps/erpnext/erpnext/projects/doctype/project/project.py +62,Expected End Date can not be less than Expected Start Date,Væntanlegur Lokadagur má ekki vera minna en búist Start Date
apps/erpnext/erpnext/utilities/transaction_base.py +110,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Gefa skal vera það sama og {1}: {2} ({3} / {4})
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,Ný Leave Umsókn
,Batch Item Expiry Status,Hópur Item Fyrning Staða
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +146,Bank Draft,Bank Draft
DocType: Mode of Payment Account,Mode of Payment Account,Mode greiðslureikning
apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Sýna Afbrigði
DocType: Academic Term,Academic Term,fræðihugtak
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,efni
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +665,Quantity,magn
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Reikninga borð getur ekki verið autt.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Loans (Liabilities),Lán (skulda)
DocType: Employee Education,Year of Passing,Ár Passing
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: %s, Item Code: %s and Customer: %s","Tilvísun:% s, Item Code:% s og viðskiptavinar:% s"
DocType: Item,Country of Origin,Upprunaland
apps/erpnext/erpnext/templates/form_grid/stock_entry_grid.html +26,In Stock,Á lager
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Opið Issues
DocType: Production Plan Item,Production Plan Item,Framleiðsla Plan Item
apps/erpnext/erpnext/hr/doctype/employee/employee.py +144,User {0} is already assigned to Employee {1},User {0} er þegar úthlutað til starfsmanns {1}
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +31,Health Care,Heilbrigðisþjónusta
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Töf á greiðslu (dagar)
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,þjónusta Expense
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +839,Serial Number: {0} is already referenced in Sales Invoice: {1},Raðnúmer: {0} er nú þegar vísað í sölureikning: {1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +804,Invoice,reikningur
DocType: Maintenance Schedule Item,Periodicity,tíðni
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Reikningsár {0} er krafist
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +54,Expected Delivery Date is be before Sales Order Date,Áætlaðan fæðingardag er að vera áður Sales Order Dagsetning
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +21,Defense,Defense
DocType: Salary Component,Abbr,skammst
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},Row {0}: {1} {2} passar ekki við {3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +75,Row # {0}:,Row # {0}:
DocType: Timesheet,Total Costing Amount,Alls Kosta Upphæð
DocType: Delivery Note,Vehicle No,ökutæki Nei
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +150,Please select Price List,Vinsamlegast veldu verðskrá
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Greiðsla skjal er þarf til að ljúka trasaction
DocType: Production Order Operation,Work In Progress,Verk í vinnslu
apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +13,Please select date,Vinsamlegast veldu dagsetningu
DocType: Employee,Holiday List,Holiday List
apps/erpnext/erpnext/public/js/setup_wizard.js +210,Accountant,endurskoðandi
DocType: Cost Center,Stock User,Stock User
DocType: Company,Phone No,Sími nei
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +50,Course Schedules created:,Course Skrár búið:
apps/erpnext/erpnext/controllers/recurring_document.py +135,New {0}: #{1},New {0}: # {1}
,Sales Partners Commission,Velta Partners Commission
apps/erpnext/erpnext/setup/doctype/company/company.py +44,Abbreviation cannot have more than 5 characters,Skammstöfun getur ekki haft fleiri en 5 stafi
DocType: Payment Request,Payment Request,greiðsla Beiðni
DocType: Asset,Value After Depreciation,Gildi Eftir Afskriftir
DocType: Employee,O+,O +
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +17,Related,Tengdar
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,Mæting dagsetning má ekki vera minna en inngöngu dagsetningu starfsmanns
DocType: Grading Scale,Grading Scale Name,Flokkun Scale Name
apps/erpnext/erpnext/accounts/doctype/account/account.js +26,This is a root account and cannot be edited.,Þetta er rót reikningur og ekki hægt að breyta.
DocType: BOM,Operations,aðgerðir
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Get ekki stillt leyfi á grundvelli afsláttur fyrir {0}
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Hengja .csv skrá með tveimur dálka, einn fyrir gamla nafn og einn fyrir nýju nafni"
apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} ekki í hvaða virka Fiscal Year.
DocType: Packed Item,Parent Detail docname,Parent Detail DOCNAME
apps/erpnext/erpnext/public/js/setup_wizard.js +303,Kg,kg
DocType: Student Log,Log,Log
apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Opnun fyrir Job.
DocType: Item Attribute,Increment,vöxtur
apps/erpnext/erpnext/public/js/stock_analytics.js +62,Select Warehouse...,Veldu Warehouse ...
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +6,Advertising,Auglýsingar
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Sama fyrirtæki er slegið oftar en einu sinni
DocType: Employee,Married,giftur
apps/erpnext/erpnext/accounts/party.py +41,Not permitted for {0},Ekki leyft {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +556,Get items from,Fá atriði úr
apps/erpnext/erpnext/hr/doctype/employee/employee.py +23,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vinsamlega settu upp starfsmannamiðlunarkerfi í mannauði&gt; HR-stillingar
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +438,Stock cannot be updated against Delivery Note {0},Stock Ekki er hægt að uppfæra móti afhendingarseðlinum {0}
apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Vara {0}
apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Engin atriði skráð
DocType: Payment Reconciliation,Reconcile,sætta
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +30,Grocery,matvöruverslun
DocType: Quality Inspection Reading,Reading 1,lestur 1
DocType: Process Payroll,Make Bank Entry,Gera Bank færslu
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +40,Pension Funds,lífeyrissjóðir
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +88,Next Depreciation Date cannot be before Purchase Date,Næsta Afskriftir Dagsetning má ekki vera áður kaupdegi
DocType: SMS Center,All Sales Person,Allt Sales Person
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Mánaðarleg dreifing ** hjálpar þér að dreifa fjárhagsáætlunar / Target yfir mánuði ef þú ert árstíðasveiflu í fyrirtæki þínu.
apps/erpnext/erpnext/accounts/page/pos/pos.js +1632,Not items found,Ekki atriði fundust
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178,Salary Structure Missing,Laun Uppbygging vantar
DocType: Lead,Person Name,Sá Name
DocType: Sales Invoice Item,Sales Invoice Item,Velta Invoice Item
DocType: Account,Credit,Credit
DocType: POS Profile,Write Off Cost Center,Skrifaðu Off Kostnaður Center
apps/erpnext/erpnext/public/js/setup_wizard.js +51,"e.g. ""Primary School"" or ""University""",td &quot;Primary School&quot; eða &quot;University&quot;
apps/erpnext/erpnext/config/stock.py +32,Stock Reports,lager Skýrslur
DocType: Warehouse,Warehouse Detail,Warehouse Detail
apps/erpnext/erpnext/selling/doctype/customer/customer.py +154,Credit limit has been crossed for customer {0} {1}/{2},Hámarksupphæð hefur verið yfir fyrir viðskiptavin {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.,Hugtakið Lokadagur getur ekki verið síðar en árslok Dagsetning skólaárið sem hugtakið er tengt (skólaárið {}). Vinsamlega leiðréttu dagsetningar og reyndu aftur.
apps/erpnext/erpnext/stock/doctype/item/item.py +472,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item","&quot;Er Fast Asset&quot; getur ekki verið valið, eins Asset met hendi á móti hlut"
DocType: Vehicle Service,Brake Oil,Brake Oil
DocType: Tax Rule,Tax Type,Tax Type
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Þú hefur ekki heimild til að bæta við eða endurnýja færslum áður {0}
DocType: BOM,Item Image (if not slideshow),Liður Image (ef ekki myndasýning)
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,An Customer exists with same name,An Viðskiptavinur til staðar með sama nafni
DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hour Rate / 60) * Raunveruleg Rekstur Time
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +889,Select BOM,Veldu 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,Kostnaður við afhent Items
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,The frídagur á {0} er ekki á milli Frá Dagsetning og hingað
DocType: Student Log,Student Log,Student Log
DocType: Quality Inspection,Get Specification Details,Fá upplýsingar eru
DocType: Lead,Interested,áhuga
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +171,Opening,opnun
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +28,From {0} to {1},Frá {0} til {1}
DocType: Item,Copy From Item Group,Afrita Frá Item Group
DocType: Journal Entry,Opening Entry,opnun Entry
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Reikningur Pay Aðeins
DocType: Employee Loan,Repay Over Number of Periods,Endurgreiða yfir fjölda tímum
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +37,{0} - {1} is not enrolled in the given {2},{0} - {1} er ekki skráður í gefinn {2}
DocType: Stock Entry,Additional Costs,viðbótarkostnað
apps/erpnext/erpnext/accounts/doctype/account/account.py +142,Account with existing transaction can not be converted to group.,Reikningur með núverandi viðskipti er ekki hægt að breyta í hópinn.
DocType: Lead,Product Enquiry,vara Fyrirspurnir
DocType: Academic Term,Schools,skólar
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Ekkert leyfi fannst fyrir starfsmann {0} fyrir {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Vinsamlegast sláðu fyrirtæki fyrst
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +333,Please select Company first,Vinsamlegast veldu Company fyrst
DocType: Employee Education,Under Graduate,undir Graduate
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,Heildar kostnaður
DocType: Journal Entry Account,Employee Loan,starfsmaður Lán
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +89,Activity Log:,Afþreying Log:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +227,Item {0} does not exist in the system or has expired,Liður {0} er ekki til í kerfinu eða er útrunnið
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +44,Real Estate,Fasteign
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +7,Statement of Account,Reikningsyfirlit
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +41,Pharmaceuticals,Pharmaceuticals
DocType: Purchase Invoice Item,Is Fixed Asset,Er fast eign
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +233,"Available qty is {0}, you need {1}","Laus Magn er {0}, þú þarft {1}"
DocType: Expense Claim Detail,Claim Amount,bótafjárhæðir
DocType: Employee,Mr,herra
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +49,Duplicate customer group found in the cutomer group table,Afrit viðskiptavinar hópur í cutomer töflunni
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +33,Supplier Type / Supplier,Birgir Type / Birgir
DocType: Naming Series,Prefix,forskeyti
apps/erpnext/erpnext/public/js/setup_wizard.js +300,Consumable,einnota
DocType: Employee,B-,B-
DocType: Upload Attendance,Import Log,innflutningur Log
DocType: Production Planning Tool,Pull Material Request of type Manufacture based on the above criteria,Dragðu Material Beiðni um gerð Framleiðsla byggt á ofangreindum forsendum
DocType: Training Result Employee,Grade,bekk
DocType: Sales Invoice Item,Delivered By Supplier,Samþykkt með Birgir
DocType: SMS Center,All Contact,Allt samband við
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +877,Production Order already created for all items with BOM,Framleiðslu Order þegar búið fyrir öll atriði með BOM
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +182,Annual Salary,árslaunum
DocType: Daily Work Summary,Daily Work Summary,Daily Work Yfirlit
DocType: Period Closing Voucher,Closing Fiscal Year,Lokun fjárhagsársins
apps/erpnext/erpnext/accounts/party.py +343,{0} {1} is frozen,{0} {1} er frosinn
apps/erpnext/erpnext/setup/doctype/company/company.py +133,Please select Existing Company for creating Chart of Accounts,Vinsamlegast veldu núverandi fyrirtæki til að búa til töflu yfir reikninga
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +78,Stock Expenses,lager Útgjöld
apps/erpnext/erpnext/stock/doctype/batch/batch.js +91,Select Target Warehouse,Veldu Target Warehouse
apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Vinsamlegast sláðu Valinn netfangi
DocType: Journal Entry,Contra Entry,contra Entry
DocType: Journal Entry Account,Credit in Company Currency,Credit í félaginu Gjaldmiðill
DocType: Delivery Note,Installation Status,uppsetning Staða
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +136,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",Viltu uppfæra mætingu? <br> Present: {0} \ <br> Fjarverandi: {1}
apps/erpnext/erpnext/controllers/buying_controller.py +318,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Samþykkt + Hafnað Magn verður að vera jöfn Móttekin magn fyrir lið {0}
DocType: Request for Quotation,RFQ-,RFQ-
DocType: Item,Supply Raw Materials for Purchase,Framboð Raw Materials til kaups
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +139,At least one mode of payment is required for POS invoice.,Að minnsta kosti einn háttur af greiðslu er krafist fyrir POS reikningi.
DocType: Products Settings,Show Products as a List,Sýna vörur sem lista
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","Sæktu sniðmát, fylla viðeigandi gögn og hengja við um hana. Allt dagsetningar og starfsmaður samspil völdu tímabili mun koma í sniðmát, með núverandi aðsóknarmet"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +481,Item {0} is not active or end of life has been reached,Liður {0} er ekki virkur eða enda líf hefur verið náð
apps/erpnext/erpnext/public/js/setup_wizard.js +346,Example: Basic Mathematics,Dæmi: Basic stærðfræði
apps/erpnext/erpnext/controllers/accounts_controller.py +667,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Til eru skatt í röð {0} í lið gengi, skatta í raðir {1} skal einnig"
apps/erpnext/erpnext/config/hr.py +214,Settings for HR Module,Stillingar fyrir HR Module
DocType: SMS Center,SMS Center,SMS Center
DocType: Sales Invoice,Change Amount,Breyta Upphæð
DocType: BOM Replace Tool,New BOM,ný BOM
DocType: Depreciation Schedule,Make Depreciation Entry,Gera Afskriftir færslu
DocType: Appraisal Template Goal,KRA,KRA
DocType: Lead,Request Type,Beiðni Type
apps/erpnext/erpnext/hr/doctype/offer_letter/offer_letter.js +17,Make Employee,gera starfsmanni
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +14,Broadcasting,Broadcasting
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +153,Execution,framkvæmd
apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Upplýsingar um starfsemi fram.
DocType: Serial No,Maintenance Status,viðhald Staða
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1}: Birgir þörf er á móti ber að greiða reikninginn {2}
apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Atriði og Verðlagning
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Total hours: {0}
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},Frá Dagsetning ætti að vera innan fjárhagsársins. Að því gefnu Frá Dagsetning = {0}
DocType: Customer,Individual,einstök
DocType: Interest,Academics User,fræðimenn User
DocType: Cheque Print Template,Amount In Figure,Upphæð Á mynd
DocType: Employee Loan Application,Loan Info,lán Info
apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Áætlun um heimsóknir viðhald.
DocType: SMS Settings,Enter url parameter for message,Sláðu url breytu fyrir skilaboð
DocType: POS Profile,Customer Groups,Hópar viðskiptavina
apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,Ársreikningur
DocType: Guardian,Students,nemendur
apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Reglur um beitingu verðlagningu og afslátt.
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,Verðlisti verður að gilda fyrir að kaupa eða selja
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Uppsetning dagsetning getur ekki verið áður fæðingardag fyrir lið {0}
DocType: Pricing Rule,Discount on Price List Rate (%),Afsláttur á verðlista Rate (%)
DocType: Offer Letter,Select Terms and Conditions,Valið Skilmálar og skilyrði
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +51,Out Value,út Value
DocType: Production Planning Tool,Sales Orders,velta Pantanir
DocType: Purchase Taxes and Charges,Valuation,verðmat
,Purchase Order Trends,Purchase Order Trends
apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,Beiðni um tilvitnun er hægt að nálgast með því að smella á eftirfarandi tengil
apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Úthluta lauf á árinu.
DocType: SG Creation Tool Course,SG Creation Tool Course,SG Creation Tool Course
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +235,Insufficient Stock,ófullnægjandi Stock
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Slökkva Stærð Skipulags- og Time mælingar
DocType: Email Digest,New Sales Orders,Ný Velta Pantanir
DocType: Bank Guarantee,Bank Account,Bankareikning
DocType: Leave Type,Allow Negative Balance,Leyfa neikvæða stöðu
DocType: Employee,Create User,Búa til notanda
DocType: Selling Settings,Default Territory,Sjálfgefið Territory
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Sjónvarp
DocType: Production Order Operation,Updated via 'Time Log',Uppfært með &#39;Time Innskráning &quot;
apps/erpnext/erpnext/controllers/taxes_and_totals.py +417,Advance amount cannot be greater than {0} {1},Fyrirfram upphæð getur ekki verið meiri en {0} {1}
DocType: Naming Series,Series List for this Transaction,Series List fyrir þessa færslu
DocType: Company,Default Payroll Payable Account,Default Launaskrá Greiðist Reikningur
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +35,Update Email Group,Uppfæra Email Group
DocType: Sales Invoice,Is Opening Entry,Er Opnun færslu
DocType: Customer Group,Mention if non-standard receivable account applicable,Umtal ef non-staðall nái reikning við
DocType: Course Schedule,Instructor Name,kennari Name
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +176,For Warehouse is required before Submit,Fyrir Lager er krafist áður Senda
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,fékk á
DocType: Sales Partner,Reseller,sölumaður
DocType: Production Planning Tool,"If checked, Will include non-stock items in the Material Requests.",Ef hakað Mun fela ekki lager vörur í efni beiðnir.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +24,Please enter Company,Vinsamlegast sláðu Company
DocType: Delivery Note Item,Against Sales Invoice Item,Gegn sölureikningi Item
,Production Orders in Progress,Framleiðslu Pantanir í vinnslu
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Handbært fé frá fjármögnun
apps/erpnext/erpnext/accounts/page/pos/pos.js +2215,"LocalStorage is full , did not save","LocalStorage er fullt, ekki spara"
DocType: Lead,Address & Contact,Heimilisfang &amp; Hafa samband
DocType: Leave Allocation,Add unused leaves from previous allocations,Bæta ónotuðum blöð frá fyrri úthlutanir
apps/erpnext/erpnext/controllers/recurring_document.py +230,Next Recurring {0} will be created on {1},Næsta Fastir {0} verður búin til á {1}
DocType: Sales Partner,Partner website,Vefsíða Partner
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +105,Add Item,Bæta Hlutir
,Contact Name,Nafn tengiliðar
DocType: Course Assessment Criteria,Course Assessment Criteria,Námsmat Viðmið
DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Býr laun miði fyrir ofangreinda forsendum.
DocType: POS Customer Group,POS Customer Group,POS viðskiptavinar Group
DocType: Cheque Print Template,Line spacing for amount in words,Línubil fyrir fjárhæð í orðum
DocType: Vehicle,Additional Details,Önnur Nánar
apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Engin lýsing gefin
apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Beiðni um kaupin.
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Þetta er byggt á tímaskýrslum skapast gagnvart þessu verkefni
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +375,Net Pay cannot be less than 0,Net Borga má ekki vera minna en 0
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Aðeins valdir Leave samþykki getur sent þetta leyfi Umsókn
apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Relieving Date must be greater than Date of Joining,Létta Dagsetning verður að vera hærri en Dagsetning Tengja
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +190,Leaves per Year,Leaves á ári
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}: Vinsamlegast athugaðu &#39;Er Advance&#39; gegn reikninginn {1} ef þetta er fyrirfram færslu.
apps/erpnext/erpnext/stock/utils.py +189,Warehouse {0} does not belong to company {1},Warehouse {0} ekki tilheyra félaginu {1}
DocType: Email Digest,Profit & Loss,Hagnaður &amp; Tap
apps/erpnext/erpnext/public/js/setup_wizard.js +304,Litre,Litre
DocType: Task,Total Costing Amount (via Time Sheet),Total kostnaðarútreikninga Magn (með Time Sheet)
DocType: Item Website Specification,Item Website Specification,Liður Website Specification
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +477,Leave Blocked,Skildu Bannaður
apps/erpnext/erpnext/stock/doctype/item/item.py +678,Item {0} has reached its end of life on {1},Liður {0} hefur náð enda sitt líf á {1}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +101,Bank Entries,Bank Entries
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +119,Annual,Árleg
DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Sættir Item
DocType: Stock Entry,Sales Invoice No,Reiknings No.
DocType: Material Request Item,Min Order Qty,Min Order Magn
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Student Group Creation Tool Course
DocType: Lead,Do Not Contact,Ekki samband
apps/erpnext/erpnext/public/js/setup_wizard.js +365,People who teach at your organisation,Fólk sem kenna í fyrirtæki þínu
DocType: Purchase Invoice,The unique id for tracking all recurring invoices. It is generated on submit.,Einstök id til að rekja allar endurteknar reikninga. Það er myndaður á senda.
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +97,Software Developer,Forritari
DocType: Item,Minimum Order Qty,Lágmark Order Magn
DocType: Pricing Rule,Supplier Type,birgir Type
DocType: Course Scheduling Tool,Course Start Date,Auðvitað Start Date
,Student Batch-Wise Attendance,Student Hópur-Wise Aðsókn
DocType: POS Profile,Allow user to edit Rate,Leyfa notanda að breyta Meta
DocType: Item,Publish in Hub,Birta á Hub
DocType: Student Admission,Student Admission,Student Aðgangseyrir
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +698,Item {0} is cancelled,Liður {0} er hætt
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +878,Material Request,efni Beiðni
DocType: Bank Reconciliation,Update Clearance Date,Uppfæra Úthreinsun Dagsetning
DocType: Item,Purchase Details,kaup Upplýsingar
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +356,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Liður {0} fannst ekki í &#39;hráefnum Meðfylgjandi&#39; borð í Purchase Order {1}
DocType: Employee,Relation,relation
DocType: Shipping Rule,Worldwide Shipping,Worldwide Shipping
DocType: Student Guardian,Mother,móðir
apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Staðfest pantanir frá viðskiptavinum.
DocType: Purchase Receipt Item,Rejected Quantity,hafnað Magn
DocType: SMS Settings,SMS Sender Name,SMS Sendandi Nafn
DocType: Notification Control,Notification Control,Tilkynning Control
DocType: Lead,Suggestions,tillögur
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Setja Item Group-vitur fjárveitingar á þessum Territory. Þú getur einnig falið í sér árstíðasveiflu með því að setja dreifingu.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Greiðsla gegn {0} {1} getur ekki verið meiri en Kröfuvirði {2}
DocType: Supplier,Address HTML,Heimilisfang HTML
DocType: Lead,Mobile No.,Mobile No.
DocType: Maintenance Schedule,Generate Schedule,búa Stundaskrá
DocType: Purchase Invoice Item,Expense Head,Expense Head
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138,Please select Charge Type first,Vinsamlegast veldu Charge Tegund fyrst
DocType: Student Group Student,Student Group Student,Student Group Student
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,nýjustu
DocType: Vehicle Service,Inspection,skoðun
DocType: Email Digest,New Quotations,ný Tilvitnun
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Póst laun miði að starfsmaður byggðar á völdum tölvupósti völdum í Launþegi
DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,Fyrsti Leyfi samþykkjari á listanum verður sett sem sjálfgefið Leave samþykkjari
DocType: Tax Rule,Shipping County,Sendingar County
apps/erpnext/erpnext/config/desktop.py +158,Learn,Frekari
DocType: Asset,Next Depreciation Date,Næsta Afskriftir Dagsetning
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Virkni Kostnaður á hvern starfsmann
DocType: Accounts Settings,Settings for Accounts,Stillingar fyrir reikninga
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +644,Supplier Invoice No exists in Purchase Invoice {0},Birgir Invoice Nei er í kaupa Reikningar {0}
apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Stjórna velta manneskja Tree.
DocType: Job Applicant,Cover Letter,Kynningarbréf
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Framúrskarandi Tékkar og Innlán til að hreinsa
DocType: Item,Synced With Hub,Samstillt Með Hub
DocType: Vehicle,Fleet Manager,Fleet Manager
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +505,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} getur ekki verið neikvæð fyrir atriðið {2}
apps/erpnext/erpnext/setup/doctype/company/company.js +67,Wrong Password,Rangt lykilorð
DocType: Item,Variant Of,afbrigði af
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +367,Completed Qty can not be greater than 'Qty to Manufacture',Lokið Magn má ekki vera meiri en &#39;Magn í Manufacture&#39;
DocType: Period Closing Voucher,Closing Account Head,Loka reikningi Head
DocType: Employee,External Work History,Ytri Vinna Saga
apps/erpnext/erpnext/projects/doctype/task/task.py +99,Circular Reference Error,Hringlaga Tilvísun Villa
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Guardian1 Name,Guardian1 Name
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,Í orðum (Export) verður sýnileg þegar þú hefur vistað Afhending Ath.
DocType: Cheque Print Template,Distance from left edge,Fjarlægð frá vinstri kanti
apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} einingar [{1}] (# Form / tl / {1}) fannst í [{2}] (# Form / Warehouse / {2})
DocType: Lead,Industry,Iðnaður
DocType: Employee,Job Profile,Atvinna Profile
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Tilkynna með tölvupósti á sköpun sjálfvirka Material Beiðni
DocType: Journal Entry,Multi Currency,multi Gjaldmiðill
DocType: Payment Reconciliation Invoice,Invoice Type,Reikningar Type
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +842,Delivery Note,Afhendingarseðilinn
apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Setja upp Skattar
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +131,Cost of Sold Asset,Kostnaðarverð seldrar Eignastýring
apps/erpnext/erpnext/accounts/utils.py +348,Payment Entry has been modified after you pulled it. Please pull it again.,Greiðsla Entry hefur verið breytt eftir að þú draga það. Vinsamlegast rífa það aftur.
apps/erpnext/erpnext/stock/doctype/item/item.py +441,{0} entered twice in Item Tax,{0} slá inn tvisvar í lið Tax
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +114,Summary for this week and pending activities,Samantekt fyrir þessa viku og bið starfsemi
DocType: Student Applicant,Admitted,viðurkenndi
DocType: Workstation,Rent Cost,Rent Kostnaður
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Upphæð Eftir Afskriftir
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Næstu Dagbókaratriði
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +75,Please select month and year,Vinsamlegast veldu mánuði og ár
DocType: Employee,Company Email,fyrirtæki Email
DocType: GL Entry,Debit Amount in Account Currency,Debit Upphæð í Account Gjaldmiðill
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Panta gildi
apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Bank / reiðufé gagnvart aðila eða fyrir innra flytja
DocType: Shipping Rule,Valid for Countries,Gildir fyrir löndum
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,Þetta atriði er sniðmát og ekki er hægt að nota í viðskiptum. Item eiginleika verður að afrita yfir í afbrigði nema &quot;Enginn Afrita&quot; er sett
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Pöntunin Talin
apps/erpnext/erpnext/config/hr.py +234,"Employee designation (e.g. CEO, Director etc.).","Starfsmaður tilnefningu (td forstjóri, framkvæmdastjóri osfrv)."
apps/erpnext/erpnext/controllers/recurring_document.py +223,Please enter 'Repeat on Day of Month' field value,Vinsamlegast sláðu inn &quot;Endurtakið á Dagur mánaðar &#39;gildissvæðið
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Gengi sem viðskiptavinir Gjaldmiðill er breytt til grunngj.miðil viðskiptavinarins
DocType: Course Scheduling Tool,Course Scheduling Tool,Auðvitað Tímasetningar Tool
apps/erpnext/erpnext/controllers/accounts_controller.py +568,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Row # {0}: Kaup Invoice ekki hægt að gera við núverandi eign {1}
DocType: Item Tax,Tax Rate,skatthlutfall
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} þegar úthlutað fyrir starfsmann {1} fyrir tímabilið {2} til {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +845,Select Item,Veldu Item
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +142,Purchase Invoice {0} is already submitted,Purchase Invoice {0} er þegar lögð
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Row # {0}: Hópur Nei verður að vera það sama og {1} {2}
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Umbreyta til non-Group
apps/erpnext/erpnext/config/stock.py +122,Batch (lot) of an Item.,Hópur (fullt) af hlut.
DocType: C-Form Invoice Detail,Invoice Date,Dagsetning reiknings
DocType: GL Entry,Debit Amount,debet Upphæð
apps/erpnext/erpnext/accounts/party.py +235,There can only be 1 Account per Company in {0} {1},Það getur aðeins verið 1 Account á félaginu í {0} {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +391,Please see attachment,Vinsamlega sjá viðhengi
DocType: Purchase Order,% Received,% móttekin
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Búa Student Hópar
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +21,Setup Already Complete!!,Skipulag þegar lokið !!
,Finished Goods,fullunnum
DocType: Delivery Note,Instructions,leiðbeiningar
DocType: Quality Inspection,Inspected By,skoðað með
DocType: Maintenance Visit,Maintenance Type,viðhald Type
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serial Nei {0} ekki tilheyra afhendingarseðlinum {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,Bæta Hlutir
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Item Quality Inspection Parameter
DocType: Leave Application,Leave Approver Name,Skildu samþykkjari Nafn
DocType: Depreciation Schedule,Schedule Date,Dagskrá Dags
apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Hagnaður, Frádráttur og annar hluti Laun"
DocType: Packed Item,Packed Item,pakkað Item
apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Sjálfgefnar stillingar til að kaupa viðskiptum.
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Virkni Kostnaður er til fyrir Starfsmaður {0} gegn Activity Tegund - {1}
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory field - Get Students From,Lögboðið reit - Fá nemendur frá
DocType: Program Enrollment,Enrolled courses,Skráðir námskeið
DocType: Currency Exchange,Currency Exchange,gjaldeyri
DocType: Asset,Item Name,Item Name
DocType: Authorization Rule,Approving User  (above authorized value),Samþykkir notandi (yfir viðurkennda gildi)
DocType: Email Digest,Credit Balance,Inneignin
DocType: Employee,Widowed,Ekkja
DocType: Request for Quotation,Request for Quotation,Beiðni um tilvitnun
DocType: Salary Slip Timesheet,Working Hours,Vinnutími
DocType: Naming Series,Change the starting / current sequence number of an existing series.,Breyta upphafsdegi / núverandi raðnúmer núverandi röð.
apps/erpnext/erpnext/accounts/page/pos/pos.js +1366,Create a new Customer,Búa til nýja viðskiptavini
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +57,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Ef margir Verðlagning Reglur halda áfram að sigra, eru notendur beðnir um að setja Forgangur höndunum til að leysa deiluna."
apps/erpnext/erpnext/utilities/activation.py +88,Create Purchase Orders,Búa innkaupapantana
,Purchase Register,kaup Register
DocType: Course Scheduling Tool,Rechedule,Rechedule
DocType: Landed Cost Item,Applicable Charges,gildandi Gjöld
DocType: Workstation,Consumable Cost,einnota Kostnaður
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +220,{0} ({1}) must have role 'Leave Approver',{0} ({1}) verða að hafa hlutverk &#39;Yfirgefa samþykkjari&#39;
DocType: Purchase Receipt,Vehicle Date,ökutæki Dagsetning
DocType: Student Log,Medical,Medical
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +180,Reason for losing,Ástæðan fyrir að tapa
apps/erpnext/erpnext/crm/doctype/lead/lead.py +41,Lead Owner cannot be same as the Lead,Lead Eigandi getur ekki verið sama og Lead
apps/erpnext/erpnext/accounts/utils.py +354,Allocated amount can not greater than unadjusted amount,Úthlutað magn getur ekki hærri en óleiðréttum upphæð
DocType: Announcement,Receiver,Receiver
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Vinnustöð er lokað á eftirfarandi dögum eins og á Holiday List: {0}
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,tækifæri
DocType: Employee,Single,Single
DocType: Salary Slip,Total Loan Repayment,Alls Loan Endurgreiðsla
DocType: Account,Cost of Goods Sold,Kostnaður af seldum vörum
DocType: Purchase Invoice,Yearly,Árlega
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +228,Please enter Cost Center,Vinsamlegast sláðu Kostnaður Center
DocType: Journal Entry Account,Sales Order,Sölupöntun
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Selling Rate,Avg. sölugengi
DocType: Assessment Plan,Examiner Name,prófdómari Name
DocType: Purchase Invoice Item,Quantity and Rate,Magn og Rate
DocType: Delivery Note,% Installed,% Uppsett
apps/erpnext/erpnext/public/js/setup_wizard.js +383,Classrooms/ Laboratories etc where lectures can be scheduled.,Kennslustofur / Laboratories etc þar fyrirlestra geta vera tímaáætlun.
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Vinsamlegast sláðu inn nafn fyrirtækis fyrst
DocType: Purchase Invoice,Supplier Name,Nafn birgja
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Lestu ERPNext Manual
DocType: Account,Is Group,er hópur
DocType: Email Digest,Pending Purchase Orders,Bíður Purchase Pantanir
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Sjálfkrafa Setja Serial Nos miðað FIFO
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Athuga Birgir Reikningur númer Sérstöðu
DocType: Vehicle Service,Oil Change,olía Breyta
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',&quot;Til Case No. &#39; má ekki vera minna en &quot;Frá Case nr &#39;
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +108,Non Profit,non Profit
DocType: Production Order,Not Started,ekki byrjað
DocType: Lead,Channel Partner,Channel Partner
DocType: Account,Old Parent,Old Parent
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +18,Mandatory field - Academic Year,Skyldanlegt námskeið - námsár
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Sérsníða inngangs texta sem fer eins og a hluti af þeim tölvupósti. Hver viðskipti er sérstakt inngangs texta.
apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Global stillingar fyrir alla framleiðsluaðferðum.
DocType: Accounts Settings,Accounts Frozen Upto,Reikninga Frozen uppí
DocType: SMS Log,Sent On,sendi á
apps/erpnext/erpnext/stock/doctype/item/item.py +640,Attribute {0} selected multiple times in Attributes Table,Eiginleiki {0} valin mörgum sinnum í eigindum töflu
DocType: HR Settings,Employee record is created using selected field. ,Starfsmaður færsla er búin til með völdu sviði.
DocType: Sales Order,Not Applicable,Á ekki við
apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Holiday skipstjóri.
DocType: Request for Quotation Item,Required Date,Áskilið Dagsetning
DocType: Delivery Note,Billing Address,Greiðslufang
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +877,Please enter Item Code.,Vinsamlegast sláðu Item Code.
DocType: BOM,Costing,kosta
DocType: Tax Rule,Billing County,Innheimta County
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount",Ef hakað skattur upphæð verður að teljast þegar innifalið í Print Rate / Prenta Upphæð
DocType: Request for Quotation,Message for Supplier,Skilaboð til Birgir
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Total Magn
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Guardian2 Email ID,Guardian2 Netfang
DocType: Item,Show in Website (Variant),Sýna í Website (Variant)
DocType: Employee,Health Concerns,Heilsa Áhyggjuefni
DocType: Process Payroll,Select Payroll Period,Veldu Launaskrá Tímabil
DocType: Purchase Invoice,Unpaid,ógreitt
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Frátekið til sölu
DocType: Packing Slip,From Package No.,Frá pakkinn nr
DocType: Item Attribute,To Range,til Hóflegt
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Verðbréfa
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","Ekki er hægt að breyta matunaraðferð, þar sem viðskipti eiga sér stað gegn sumum hlutum sem ekki hafa eigin matunaraðferð"
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Samtals lauf úthlutað er nauðsynlegur
DocType: Job Opening,Description of a Job Opening,Lýsing á starf opnun
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +111,Pending activities for today,Bið starfsemi fyrir dag
apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Aðsókn met.
DocType: Salary Structure,Salary Component for timesheet based payroll.,Laun Component fyrir timesheet byggt launaskrá.
DocType: Sales Order Item,Used for Production Plan,Notað fyrir framleiðslu áætlun
DocType: Employee Loan,Total Payment,Samtals greiðsla
DocType: Manufacturing Settings,Time Between Operations (in mins),Tími milli rekstrar (í mín)
DocType: Customer,Buyer of Goods and Services.,Kaupandi vöru og þjónustu.
DocType: Journal Entry,Accounts Payable,Viðskiptaskuldir
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +29,The selected BOMs are not for the same item,Völdu BOMs eru ekki fyrir sama hlut
DocType: Pricing Rule,Valid Upto,gildir uppí
DocType: Training Event,Workshop,Workshop
apps/erpnext/erpnext/public/js/setup_wizard.js +243,List a few of your customers. They could be organizations or individuals.,Listi nokkrar af viðskiptavinum þínum. Þeir gætu verið stofnanir eða einstaklingar.
,Enough Parts to Build,Nóg Varahlutir til að byggja
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Direct Income,bein Tekjur
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Account, if grouped by Account","Getur ekki síað byggð á reikning, ef flokkaðar eftir reikningi"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +92,Administrative Officer,Administrative Officer
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +22,Please select Course,Vinsamlegast veldu Námskeið
DocType: Timesheet Detail,Hrs,Hrs
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +317,Please select Company,Vinsamlegast veldu Company
DocType: Stock Entry Detail,Difference Account,munurinn Reikningur
apps/erpnext/erpnext/projects/doctype/task/task.py +46,Cannot close task as its dependant task {0} is not closed.,Get ekki loka verkefni eins háð verkefni hennar {0} er ekki lokað.
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +433,Please enter Warehouse for which Material Request will be raised,Vinsamlegast sláðu Warehouse sem efni Beiðni verði hækkað
DocType: Production Order,Additional Operating Cost,Viðbótarupplýsingar rekstrarkostnaður
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +20,Cosmetics,snyrtivörur
apps/erpnext/erpnext/stock/doctype/item/item.py +536,"To merge, following properties must be same for both items","Að sameinast, eftirfarandi eiginleika verða að vera það sama fyrir bæði atriði"
DocType: Shipping Rule,Net Weight,Net Weight
DocType: Employee,Emergency Phone,Neyðarnúmer Sími
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,kaupa
,Serial No Warranty Expiry,Serial Nei Ábyrgð gildir til
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%,Vinsamlegast tilgreindu einkunn fyrir Þröskuld 0%
DocType: Sales Order,To Deliver,til Bera
DocType: Purchase Invoice Item,Item,Item
apps/erpnext/erpnext/accounts/page/pos/pos.js +2378,Serial no item cannot be a fraction,Serial engin lið getur ekki verið brot
DocType: Journal Entry,Difference (Dr - Cr),Munur (Dr - Cr)
DocType: Account,Profit and Loss,Hagnaður og tap
apps/erpnext/erpnext/config/stock.py +325,Managing Subcontracting,Annast undirverktöku
DocType: Project,Project will be accessible on the website to these users,Verkefnið verður aðgengilegur á vef þessara notenda
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Gengi sem Verðskrá mynt er breytt í grunngj.miðil félagsins
apps/erpnext/erpnext/setup/doctype/company/company.py +59,Account {0} does not belong to company: {1},Reikningur {0} ekki tilheyra fyrirtæki: {1}
apps/erpnext/erpnext/setup/doctype/company/company.py +50,Abbreviation already used for another company,Skammstöfun þegar notuð fyrir annað fyrirtæki
DocType: Selling Settings,Default Customer Group,Sjálfgefið Group Viðskiptavinur
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction",Ef öryrkjar &#39;ávöl Samtals&#39; reitur verður ekki sýnilegt í öllum viðskiptum
DocType: BOM,Operating Cost,Rekstrarkostnaður
DocType: Sales Order Item,Gross Profit,Framlegð
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Vöxtur getur ekki verið 0
DocType: Production Planning Tool,Material Requirement,efni Krafa
DocType: Company,Delete Company Transactions,Eyða Transactions Fyrirtækið
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +323,Reference No and Reference Date is mandatory for Bank transaction,Tilvísun Nei og Frestdagur er nauðsynlegur fyrir banka viðskiptin
DocType: Purchase Receipt,Add / Edit Taxes and Charges,Bæta við / breyta sköttum og gjöldum
DocType: Purchase Invoice,Supplier Invoice No,Birgir Reikningur nr
DocType: Territory,For reference,til viðmiðunar
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +154,"Cannot delete Serial No {0}, as it is used in stock transactions","Ekki hægt að eyða Serial Nei {0}, eins og það er notað í lager viðskiptum"
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Cr),Lokun (Cr)
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +105,Move Item,færa Item
DocType: Serial No,Warranty Period (Days),Ábyrgðartímabilið (dagar)
DocType: Installation Note Item,Installation Note Item,Uppsetning Note Item
DocType: Production Plan Item,Pending Qty,Bíður Magn
DocType: Budget,Ignore,Hunsa
apps/erpnext/erpnext/accounts/party.py +347,{0} {1} is not active,{0} {1} er ekki virkur
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +95,SMS sent to following numbers: {0},SMS send til eftirfarandi númer: {0}
apps/erpnext/erpnext/config/accounts.py +246,Setup cheque dimensions for printing,Skipulag athuga mál fyrir prentun
DocType: Salary Slip,Salary Slip Timesheet,Laun Slip Timesheet
apps/erpnext/erpnext/controllers/buying_controller.py +150,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Birgir Warehouse nauðsynlegur fyrir undirverktaka Kvittun
DocType: Pricing Rule,Valid From,Gildir frá
DocType: Sales Invoice,Total Commission,alls Commission
DocType: Pricing Rule,Sales Partner,velta Partner
DocType: Buying Settings,Purchase Receipt Required,Kvittun Áskilið
apps/erpnext/erpnext/stock/doctype/item/item.py +129,Valuation Rate is mandatory if Opening Stock entered,Verðmat Rate er nauðsynlegur ef Opnun Stock inn
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +142,No records found in the Invoice table,Engar færslur finnast í Invoice töflunni
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +17,Please select Company and Party Type first,Vinsamlegast veldu Company og Party Gerð fyrst
apps/erpnext/erpnext/config/accounts.py +262,Financial / accounting year.,Financial / bókhald ári.
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Uppsafnaður Gildi
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Sorry, Serial Nos cannot be merged","Því miður, Serial Nos ekki hægt sameinuð"
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +736,Make Sales Order,Gera Velta Order
DocType: Project Task,Project Task,Project Task
,Lead Id,Lead Id
DocType: C-Form Invoice Detail,Grand Total,Grand Total
DocType: Training Event,Course,námskeið
DocType: Timesheet,Payslip,launaseðli
apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Atriði körfu
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Reikningsár Start Date ætti ekki að vera meiri en Fiscal Year End Date
DocType: Issue,Resolution,upplausn
DocType: C-Form,IV,IV
apps/erpnext/erpnext/templates/pages/order.html +53,Delivered: {0},Afhent: {0}
DocType: Expense Claim,Payable Account,greiðist Reikningur
DocType: Payment Entry,Type of Payment,Tegund greiðslu
DocType: Sales Order,Billing and Delivery Status,Innheimtu og skil Status
DocType: Job Applicant,Resume Attachment,Halda áfram Attachment
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,endurtaka Viðskiptavinir
DocType: Leave Control Panel,Allocate,úthluta
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +805,Sales Return,velta 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,Ath: Samtals úthlutað leyfi {0} ætti ekki að vera minna en þegar hafa verið samþykktar leyfi {1} fyrir tímabilið
DocType: Announcement,Posted By,Posted By
DocType: Item,Delivered by Supplier (Drop Ship),Samþykkt með Birgir (Drop Ship)
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Gagnagrunnur hugsanlegra viðskiptavina.
DocType: Authorization Rule,Customer or Item,Viðskiptavinur eða Item
apps/erpnext/erpnext/config/selling.py +28,Customer database.,Viðskiptavinur gagnasafn.
DocType: Quotation,Quotation To,Tilvitnun Til
DocType: Lead,Middle Income,Middle Tekjur
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Cr),Opening (Cr)
apps/erpnext/erpnext/stock/doctype/item/item.py +804,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.,Default Mælieiningin fyrir lið {0} Ekki er hægt að breyta beint vegna þess að þú hefur nú þegar gert nokkrar viðskiptin (s) með öðru UOM. Þú þarft að búa til nýjan hlut til að nota aðra Sjálfgefin UOM.
apps/erpnext/erpnext/accounts/utils.py +352,Allocated amount can not be negative,Úthlutað magn getur ekki verið neikvæð
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +25,Please set the Company,Vinsamlegast settu fyrirtækið
DocType: Purchase Order Item,Billed Amt,billed Amt
DocType: Training Result Employee,Training Result Employee,Þjálfun Niðurstaða Starfsmaður
DocType: Warehouse,A logical Warehouse against which stock entries are made.,A rökrétt Warehouse gegn sem stock færslur eru gerðar.
DocType: Repayment Schedule,Principal Amount,höfuðstóll
DocType: Employee Loan Application,Total Payable Interest,Alls Greiðist Vextir
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Velta Invoice Timesheet
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},Tilvísunarnúmer &amp; Frestdagur er nauðsynlegt fyrir {0}
DocType: Process Payroll,Select Payment Account to make Bank Entry,Veldu Greiðslureikningur að gera Bank Entry
apps/erpnext/erpnext/utilities/activation.py +134,"Create Employee records to manage leaves, expense claims and payroll","Búa Employee skrár til að stjórna lauf, kostnað kröfur og launaskrá"
apps/erpnext/erpnext/support/doctype/issue/issue.js +24,Add to Knowledge Base,Bæta við Knowledge Base
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +152,Proposal Writing,Tillaga Ritun
DocType: Payment Entry Deduction,Payment Entry Deduction,Greiðsla Entry Frádráttur
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Annar velta manneskja {0} staðar með sama Starfsmannafélag id
DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests",Ef hakað hráefni fyrir atriði sem eru undirverktakar verður með í efninu Beiðnir
apps/erpnext/erpnext/config/accounts.py +80,Masters,Masters
DocType: Assessment Plan,Maximum Assessment Score,Hámarks Mat Einkunn
apps/erpnext/erpnext/config/accounts.py +140,Update Bank Transaction Dates,Update viðskipta banka Dagsetningar
apps/erpnext/erpnext/config/projects.py +30,Time Tracking,tími mælingar
DocType: Fiscal Year Company,Fiscal Year Company,Reikningsár Company
DocType: Packing Slip Item,DN Detail,DN Detail
DocType: Training Event,Conference,Ráðstefna
DocType: Timesheet,Billed,billed
DocType: Batch,Batch Description,hópur Lýsing
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Búa til nemendahópa
apps/erpnext/erpnext/accounts/utils.py +720,"Payment Gateway Account not created, please create one manually.",Greiðsla Gateway Reikningur ekki búin skaltu búa til einn höndunum.
DocType: Sales Invoice,Sales Taxes and Charges,Velta Skattar og gjöld
DocType: Employee,Organization Profile,Organization Profile
DocType: Student,Sibling Details,systkini Upplýsingar
DocType: Vehicle Service,Vehicle Service,Vehicle Service
apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Sjálfkrafa kallar á viðbrögð beiðnin byggist á aðstæðum.
DocType: Employee,Reason for Resignation,Ástæðan fyrir úrsögn
apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Sniðmát fyrir úttektum árangur.
DocType: Sales Invoice,Credit Note Issued,Credit Note Útgefið
DocType: Project Task,Weight,þyngd
DocType: Payment Reconciliation,Invoice/Journal Entry Details,Invoice / Journal Entry Details
apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} &#39;{1}&#39; ekki í Fiscal Year {2}
DocType: Buying Settings,Settings for Buying Module,Stillingar fyrir Buying Module
apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},Eignastýring {0} ekki tilheyra félaginu {1}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +69,Please enter Purchase Receipt first,Vinsamlegast sláðu inn kvittun fyrst
DocType: Buying Settings,Supplier Naming By,Birgir Nafngift By
DocType: Activity Type,Default Costing Rate,Sjálfgefið Kosta Rate
DocType: Maintenance Schedule,Maintenance Schedule,viðhald Dagskrá
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +34,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Þá Verðlagning Reglur eru síuð út byggðar á viðskiptavininn, viðskiptavini Group, Territory, Birgir, Birgir Tegund, Campaign, Sales Partner o.fl."
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Net Breyting á Skrá
apps/erpnext/erpnext/config/hr.py +157,Employee Loan Management,Starfsmaður Lán Stjórnun
DocType: Employee,Passport Number,Vegabréfs númer
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Relation with Guardian2,Tengsl Guardian2
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Manager,framkvæmdastjóri
DocType: Payment Entry,Payment From / To,Greiðsla Frá / Til
apps/erpnext/erpnext/selling/doctype/customer/customer.py +117,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Ný hámarksupphæð er minna en núverandi útistandandi upphæð fyrir viðskiptavininn. Hámarksupphæð þarf að vera atleast {0}
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +258,Same item has been entered multiple times.,Sama atriði hefur verið slegið mörgum sinnum.
DocType: SMS Settings,Receiver Parameter,Receiver Parameter
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,"""Byggt á' og 'hópað eftir' getur ekki verið það sama"
DocType: Sales Person,Sales Person Targets,Velta Person markmið
DocType: Installation Note,IN-,í-
DocType: Production Order Operation,In minutes,í mínútum
DocType: Issue,Resolution Date,upplausn Dagsetning
DocType: Student Batch Name,Batch Name,hópur Name
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +319,Timesheet created:,Timesheet búið:
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +859,Please set default Cash or Bank account in Mode of Payment {0},Vinsamlegast settu sjálfgefinn Cash eða bankareikning í háttur á greiðslu {0}
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +20,Enroll,innritast
DocType: Selling Settings,Customer Naming By,Viðskiptavinur Nafngift By
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Mun sýna nemandann eins staðar í námsmanna Monthly Aðsókn Report
DocType: Depreciation Schedule,Depreciation Amount,Afskriftir Upphæð
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Umbreyta í Group
DocType: Activity Cost,Activity Type,virkni Type
DocType: Request for Quotation,For individual supplier,Fyrir einstaka birgi
DocType: BOM Operation,Base Hour Rate(Company Currency),Base Hour Rate (Company Gjaldmiðill)
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Skilað Upphæð
DocType: Supplier,Fixed Days,Varanlegir Days
DocType: Quotation Item,Item Balance,Liður Balance
DocType: Sales Invoice,Packing List,Pökkunarlisti
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Purchase Pantanir gefið birgja.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +43,Publishing,Publishing
DocType: Activity Cost,Projects User,verkefni User
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,neytt
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} fannst ekki í Reikningsupplýsingar töflu
DocType: Company,Round Off Cost Center,Umferð Off Kostnaður Center
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +218,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Viðhald Visit {0} verður lokað áður en hætta þessu Velta Order
DocType: Item,Material Transfer,efni Transfer
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},Staða timestamp verður að vera eftir {0}
DocType: Employee Loan,Total Interest Payable,Samtals vaxtagjöld
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Landað Kostnaður Skattar og gjöld
DocType: Production Order Operation,Actual Start Time,Raunveruleg Start Time
DocType: BOM Operation,Operation Time,Operation Time
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +139,Finish,Ljúka
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +386,Base,Base
DocType: Timesheet,Total Billed Hours,Samtals Greidd Hours
DocType: Journal Entry,Write Off Amount,Skrifaðu Off Upphæð
DocType: Journal Entry,Bill No,Bill Nei
DocType: Company,Gain/Loss Account on Asset Disposal,Hagnaður / tap reikning á Asset förgun
DocType: Vehicle Log,Service Details,Upplýsingar um þjónustu
DocType: Purchase Invoice,Quarterly,ársfjórðungslega
DocType: Selling Settings,Delivery Note Required,Afhending Note Áskilið
DocType: Bank Guarantee,Bank Guarantee Number,Bankareikningsnúmer
DocType: Assessment Criteria,Assessment Criteria,Námsmat Viðmið
DocType: BOM Item,Basic Rate (Company Currency),Basic Rate (Company Gjaldmiðill)
DocType: Student Attendance,Student Attendance,Student Aðsókn
DocType: Sales Invoice Timesheet,Time Sheet,Tímatafla
DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush Raw Materials miðað við
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +62,Please enter item details,Vinsamlegast sláðu inn Item upplýsingar
DocType: Interest,Interest,vextir
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Forsala
DocType: Purchase Receipt,Other Details,aðrar upplýsingar
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,suplier
DocType: Account,Accounts,Reikningar
DocType: Vehicle,Odometer Value (Last),Kílómetramæli Value (Last)
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +71,Marketing,markaðssetning
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +282,Payment Entry is already created,Greiðsla Entry er þegar búið
DocType: Purchase Receipt Item Supplied,Current Stock,Núverandi Stock
apps/erpnext/erpnext/controllers/accounts_controller.py +555,Row #{0}: Asset {1} does not linked to Item {2},Row # {0}: Asset {1} er ekki tengd við lið {2}
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +368,Preview Salary Slip,Preview Laun Slip
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Reikningur {0} hefur verið slegið mörgum sinnum
DocType: Account,Expenses Included In Valuation,Kostnaður í Verðmat
DocType: Hub Settings,Seller City,Seljandi City
,Absent Student Report,Absent Student Report
DocType: Email Digest,Next email will be sent on:,Næst verður send í tölvupósti á:
DocType: Offer Letter Term,Offer Letter Term,Tilboð Letter Term
apps/erpnext/erpnext/stock/doctype/item/item.py +619,Item has variants.,Liður hefur afbrigði.
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Liður {0} fannst ekki
DocType: Bin,Stock Value,Stock Value
apps/erpnext/erpnext/accounts/doctype/account/account.py +26,Company {0} does not exist,Fyrirtæki {0} er ekki til
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +84,Tree Type,Tree Tegund
DocType: BOM Explosion Item,Qty Consumed Per Unit,Magn neytt á Unit
DocType: Serial No,Warranty Expiry Date,Ábyrgð í Fyrningardagsetning
DocType: Material Request Item,Quantity and Warehouse,Magn og Warehouse
DocType: Sales Invoice,Commission Rate (%),Þóknun Rate (%)
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +24,Please select Program,Vinsamlegast veldu Forrit
DocType: Project,Estimated Cost,áætlaður kostnaður
DocType: Purchase Order,Link to material requests,Tengill á efni beiðna
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Aerospace
DocType: Journal Entry,Credit Card Entry,Credit Card Entry
apps/erpnext/erpnext/config/accounts.py +51,Company and Accounts,Fyrirtæki og reikningar
apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Vörur sem berast frá birgja.
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +49,In Value,Virði
DocType: Lead,Campaign Name,Heiti herferðar
DocType: Selling Settings,Close Opportunity After Days,Loka Tækifæri Eftir daga
,Reserved,frátekin
DocType: Purchase Order,Supply Raw Materials,Supply Raw Materials
DocType: Purchase Invoice,The date on which next invoice will be generated. It is generated on submit.,Dagsetningin sem næst verður reikningur mynda. Það er myndaður á senda.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Veltufjármunir
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93,{0} is not a stock Item,{0} er ekki birgðir Item
DocType: Mode of Payment Account,Default Account,Sjálfgefið Reikningur
DocType: Payment Entry,Received Amount (Company Currency),Fékk Magn (Company Gjaldmiðill)
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +167,Lead must be set if Opportunity is made from Lead,Lead verður að setja ef Tækifæri er gert úr Lead
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Vinsamlegast veldu viku burt daginn
DocType: Production Order Operation,Planned End Time,Planned Lokatími
,Sales Person Target Variance Item Group-Wise,Velta Person Target Dreifni Item Group-Wise
apps/erpnext/erpnext/accounts/doctype/account/account.py +97,Account with existing transaction cannot be converted to ledger,Reikningur með núverandi viðskipti er ekki hægt að breyta í höfuðbók
DocType: Delivery Note,Customer's Purchase Order No,Purchase Order No viðskiptavinar
DocType: Budget,Budget Against,Budget Against
DocType: Employee,Cell Number,Cell Number
apps/erpnext/erpnext/stock/reorder_item.py +177,Auto Material Requests Generated,Auto Efni Beiðnir Myndað
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Lost
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,Þú getur ekki slá núverandi skírteini í &quot;Against dagbókarfærslu &#39;dálki
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Frátekið fyrir framleiðslu
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,Orka
DocType: Opportunity,Opportunity From,tækifæri Frá
apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Mánaðarlaun yfirlýsingu.
DocType: BOM,Website Specifications,Vefsíða Upplýsingar
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0}: Frá {0} tegund {1}
DocType: Warranty Claim,CI-,CI-
apps/erpnext/erpnext/controllers/buying_controller.py +284,Row {0}: Conversion Factor is mandatory,Row {0}: viðskipta Factor er nauðsynlegur
DocType: Employee,A+,A +
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +325,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Margar verð Reglur hendi með sömu forsendum, vinsamlegast leysa deiluna með því að úthluta forgang. Verð Reglur: {0}"
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +434,Cannot deactivate or cancel BOM as it is linked with other BOMs,Ekki er hægt að slökkva eða hætta BOM eins og það er tengt við önnur BOMs
DocType: Opportunity,Maintenance,viðhald
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +214,Purchase Receipt number required for Item {0},Kvittun tala krafist fyrir lið {0}
DocType: Item Attribute Value,Item Attribute Value,Liður Attribute gildi
apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Velta herferðir.
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +48,Make Timesheet,gera 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.","Standard skatta sniðmát sem hægt er að beita öllum sölu viðskiptum. Þessi sniðmát geta innihaldið lista yfir skatta höfuð og einnig öðrum höfuð kostnað / tekjur eins og &quot;Shipping&quot;, &quot;tryggingar&quot;, &quot;Meðhöndlun&quot; osfrv #### Athugið skatthlutfall þú velur hér verður staðallinn skatthlutfallið fyrir alla ** atriði **. Ef það eru ** Items ** sem hafa mismunandi verð, verður að bæta við í ** Item Tax ** borð í ** Liður ** meistara. #### Lýsing dálka 1. Útreikningur Type: - Þetta getur verið á ** Net Total ** (sem er summa grunnfjárhæð). - ** Á fyrri umf öllum / Upphæð ** (fyrir uppsöfnuð skatta eða gjöld). Ef þú velur þennan kost, að skattur verði beitt sem hlutfall af fyrri röðinni (í skatt töflu) fjárhæð eða samtals. - ** Raunveruleg ** (eins og getið). 2. Reikningur Head: The Account höfuðbók þar sem þessi skattur verður að bóka 3. Kostnaður Center: Ef skattur / gjald er tekjur (eins skipum) eða gjaldaliði það þarf að bóka á móti kostnaði sent. 4. Lýsing: Lýsing á skatta (sem verður prentað í reikningum / gæsalappa). 5. Gefa: Skatthlutfall. 6. Upphæð: Skatthlutfall. 7. Samtals: Uppsöfnuð alls að þessum tímapunkti. 8. Sláðu Row: Ef byggir á &quot;Fyrri Row Total&quot; getur þú valið línunúmeri sem verður tekið sem grunn fyrir þessum útreikningi (sjálfgefið er fyrri umf). 9. Er þetta Tax innifalinn í grunntaxta ?: Ef þú athuga þetta, þá þýðir það að þessi skattur verður ekki sýnd hér fyrir neðan hlutnum borð, en verður innifalið í grunntaxta í helstu atriði töflunni. Þetta er gagnlegt þar sem þú vilt gefa íbúð verð (að meðtöldum öllum sköttum) verð til viðskiptavina."
DocType: Employee,Bank A/C No.,Bank A / C nr
DocType: Bank Guarantee,Project,Project
DocType: Quality Inspection Reading,Reading 7,lestur 7
DocType: Expense Claim Detail,Expense Claim Type,Expense Gerð kröfu
DocType: Shopping Cart Settings,Default settings for Shopping Cart,Sjálfgefnar stillingar fyrir Shopping Cart
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +132,Asset scrapped via Journal Entry {0},Eignastýring rifið um dagbókarfærslu {0}
DocType: Employee Loan,Interest Income Account,Vaxtatekjur Reikningur
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,líftækni
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +107,Office Maintenance Expenses,Skrifstofa viðhald kostnaður
apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Setja upp Email Account
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +115,Please enter Item first,Vinsamlegast sláðu inn Item fyrst
DocType: Account,Liability,Ábyrgð
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +175,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Bundnar Upphæð má ekki vera meiri en bótafjárhæðir í Row {0}.
DocType: Company,Default Cost of Goods Sold Account,Default Kostnaðarverð seldra vara reikning
apps/erpnext/erpnext/stock/get_item_details.py +299,Price List not selected,Verðskrá ekki valið
DocType: Employee,Family Background,Family Background
DocType: Request for Quotation Supplier,Send Email,Senda tölvupóst
apps/erpnext/erpnext/stock/doctype/item/item.py +206,Warning: Invalid Attachment {0},Viðvörun: Ógild Attachment {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +756,No Permission,engin heimild
DocType: Company,Default Bank Account,Sjálfgefið Bank Account
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +50,"To filter based on Party, select Party Type first","Að sía byggt á samningsaðila, velja Party Sláðu fyrst"
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},&#39;Uppfæra Stock&#39; Ekki er hægt að athuga vegna þess að hlutir eru ekki send með {0}
DocType: Vehicle,Acquisition Date,yfirtökudegi
apps/erpnext/erpnext/public/js/setup_wizard.js +303,Nos,nos
DocType: Item,Items with higher weightage will be shown higher,Verk með hærri weightage verður sýnt meiri
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Bank Sættir Detail
apps/erpnext/erpnext/controllers/accounts_controller.py +559,Row #{0}: Asset {1} must be submitted,Row # {0}: Asset {1} Leggja skal fram
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Enginn starfsmaður fannst
DocType: Supplier Quotation,Stopped,Tappi
DocType: Item,If subcontracted to a vendor,Ef undirverktaka til seljanda
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +95,Student Group is already updated.,Nemendahópur er þegar uppfærð.
DocType: SMS Center,All Customer Contact,Allt Viðskiptavinur samband við
apps/erpnext/erpnext/config/stock.py +153,Upload stock balance via csv.,Hlaða lager jafnvægi í gegnum CSV.
DocType: Warehouse,Tree Details,Tree Upplýsingar
DocType: Training Event,Event Status,Event Staða
,Support Analytics,Stuðningur Analytics
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +344,"If you have any questions, please get back to us.","Ef þú hefur einhverjar spurningar, vinsamlegast komast aftur til okkar."
DocType: Item,Website Warehouse,Vefsíða Warehouse
DocType: Payment Reconciliation,Minimum Invoice Amount,Lágmark Reikningsupphæð
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Kostnaður Center {2} ekki tilheyra félaginu {3}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1}: Account {2} getur ekki verið Group
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Liður Row {idx}: {DOCTYPE} {DOCNAME} er ekki til í að ofan &#39;{DOCTYPE}&#39; borð
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +271,Timesheet {0} is already completed or cancelled,Timesheet {0} er þegar lokið eða hætt
apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Engin verkefni
DocType: Purchase Invoice,"The day of the month on which auto invoice will be generated e.g. 05, 28 etc","Dagur mánaðarins sem farartæki reikningur vilja vera mynda td 05, 28 osfrv"
DocType: Asset,Opening Accumulated Depreciation,Opnun uppsöfnuðum afskriftum
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Score þarf að vera minna en eða jafnt og 5
DocType: Program Enrollment Tool,Program Enrollment Tool,Program Innritun Tool
apps/erpnext/erpnext/config/accounts.py +299,C-Form records,C-Form færslur
apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Viðskiptavinur og Birgir
DocType: Email Digest,Email Digest Settings,Sendu Digest Stillingar
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +346,Thank you for your business!,Takk fyrir viðskiptin!
apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Stuðningur fyrirspurnir frá viðskiptavinum.
,Production Order Stock Report,Framleiðslu Order Stock Report
DocType: HR Settings,Retirement Age,starfslok Age
DocType: Bin,Moving Average Rate,Moving Average Meta
DocType: Production Planning Tool,Select Items,Valið Atriði
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} gegn frumvarpinu {1} dags {2}
apps/erpnext/erpnext/schools/doctype/course/course.js +17,Course Schedule,námskeið Stundaskrá
DocType: Maintenance Visit,Completion Status,Gengið Staða
DocType: HR Settings,Enter retirement age in years,Sláðu eftirlaunaaldur í ár
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +263,Target Warehouse,Target Warehouse
DocType: Cheque Print Template,Starting location from left edge,Byrjun stað frá vinstri kanti
DocType: Item,Allow over delivery or receipt upto this percent,Leyfa yfir afhendingu eða viðtöku allt uppí þennan prósent
DocType: Stock Entry,STE-,STE-
DocType: Upload Attendance,Import Attendance,innflutningur Aðsókn
apps/erpnext/erpnext/public/js/pos/pos.html +115,All Item Groups,Allir Item Hópar
DocType: Process Payroll,Activity Log,virkni Log
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +40,Net Profit / Loss,Hagnaður / Tap
apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Sjálfkrafa semja skilaboð á framlagningu viðskiptum.
DocType: Production Order,Item To Manufacture,Atriði til að framleiða
apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} staðan er {2}
DocType: Employee,Provide Email Address registered in company,Gefa upp netfang skráð í félaginu
DocType: Shopping Cart Settings,Enable Checkout,Virkja Checkout
apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Purchase Order til greiðslu
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Áætlaðar Magn
DocType: Sales Invoice,Payment Due Date,Greiðsla Due Date
apps/erpnext/erpnext/stock/doctype/item/item.js +341,Item Variant {0} already exists with same attributes,Liður Variant {0} er þegar til staðar með sömu eiginleika
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +97,'Opening',&#39;Opening&#39;
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Open Til Gera
DocType: Notification Control,Delivery Note Message,Afhending Note Message
DocType: Expense Claim,Expenses,útgjöld
DocType: Item Variant Attribute,Item Variant Attribute,Liður Variant Attribute
,Purchase Receipt Trends,Kvittun Trends
DocType: Process Payroll,Bimonthly,bimonthly
DocType: Vehicle Service,Brake Pad,Bremsuklossi
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +81,Research & Development,Rannsóknir og þróun
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Upphæð Bill
DocType: Company,Registration Details,Skráning Details
DocType: Timesheet,Total Billed Amount,Alls Billed Upphæð
DocType: Item Reorder,Re-Order Qty,Re-Order Magn
DocType: Leave Block List Date,Leave Block List Date,Skildu Block List Dagsetning
DocType: Pricing Rule,Price or Discount,Verð eða Afsláttur
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +86,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Samtals greiðsla í kvittun atriðum borðið verður að vera það sama og Samtals skatta og gjöld
DocType: Sales Team,Incentives,Incentives
DocType: SMS Log,Requested Numbers,umbeðin Numbers
DocType: Production Planning Tool,Only Obtain Raw Materials,Aðeins fá hráefni
apps/erpnext/erpnext/config/hr.py +142,Performance appraisal.,Mat á frammistöðu.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +95,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Virkjun &#39;Nota fyrir Shopping Cart&#39;, eins og Shopping Cart er virkt og það ætti að vera að minnsta kosti einn Tax Rule fyrir Shopping Cart"
apps/erpnext/erpnext/controllers/accounts_controller.py +357,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","Greiðsla Entry {0} er tengd við Order {1}, athuga hvort það ætti að vera dreginn sem fyrirfram í þessum reikningi."
DocType: Sales Invoice Item,Stock Details,Stock Nánar
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Project Value
apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Sölustaður
DocType: Vehicle Log,Odometer Reading,kílómetramæli Reading
apps/erpnext/erpnext/accounts/doctype/account/account.py +120,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Viðskiptajöfnuður þegar í Credit, þú ert ekki leyft að setja &#39;Balance Verður Be&#39; eins og &#39;Debit &quot;"
DocType: Account,Balance must be,Jafnvægi verður að vera
DocType: Hub Settings,Publish Pricing,birta Verðlagning
DocType: Notification Control,Expense Claim Rejected Message,Kostnað Krafa Hafnað skilaboð
,Available Qty,Laus Magn
DocType: Purchase Taxes and Charges,On Previous Row Total,Á fyrri röð Total
DocType: Purchase Invoice Item,Rejected Qty,hafnað Magn
DocType: Salary Slip,Working Days,Vinnudagar
DocType: Serial No,Incoming Rate,Komandi Rate
DocType: Packing Slip,Gross Weight,Heildarþyngd
apps/erpnext/erpnext/public/js/setup_wizard.js +67,The name of your company for which you are setting up this system.,Nafn fyrirtækis þíns sem þú ert að setja upp þetta kerfi.
DocType: HR Settings,Include holidays in Total no. of Working Days,Fela frí í algjöru nr. vinnudaga
DocType: Job Applicant,Hold,haldið
DocType: Employee,Date of Joining,Dagsetning Tengja
DocType: Naming Series,Update Series,Uppfæra Series
DocType: Supplier Quotation,Is Subcontracted,er undirverktöku
DocType: Item Attribute,Item Attribute Values,Liður eigindi gildi
DocType: Examination Result,Examination Result,skoðun Niðurstaða
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +791,Purchase Receipt,Kvittun
,Received Items To Be Billed,Móttekin Items verður innheimt
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +177,Submitted Salary Slips,Innsendar Laun laumar
DocType: Employee,Ms,Fröken
apps/erpnext/erpnext/config/accounts.py +272,Currency exchange rate master.,Gengi meistara.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +177,Reference Doctype must be one of {0},Tilvísun DOCTYPE verður að vera einn af {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},Ekki er hægt að finna tíma rifa á næstu {0} dögum fyrir aðgerð {1}
DocType: Production Order,Plan material for sub-assemblies,Plan efni fyrir undireiningum
apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Velta Partners og Territory
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +86,Cannot automatically create Account as there is already stock balance in the Account. You must create a matching account before you can make an entry on this warehouse,Ekki er hægt að sjálfkrafa búa reikning sem það er nú þegar Stock jafnvægi í reikninginn. Þú verður að búa til passa reikning áður en hægt er að gera færslu um þetta vöruhús
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +510,BOM {0} must be active,BOM {0} verður að vera virkt
DocType: Journal Entry,Depreciation Entry,Afskriftir Entry
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Vinsamlegast veldu tegund skjals fyrst
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Hætta Efni Heimsóknir {0} áður hætta þessu Viðhald Farðu
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +209,Serial No {0} does not belong to Item {1},Serial Nei {0} ekki tilheyra lið {1}
DocType: Purchase Receipt Item Supplied,Required Qty,Required Magn
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +223,Warehouses with existing transaction can not be converted to ledger.,Vöruhús með núverandi viðskipti er ekki hægt að breyta í höfuðbók.
DocType: Bank Reconciliation,Total Amount,Heildarupphæð
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +32,Internet Publishing,internet Publishing
DocType: Production Planning Tool,Production Orders,framleiðslu Pantanir
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +53,Balance Value,Balance Value
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Velta Verðskrá
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +69,Publish to sync items,Birta að samstilla atriði
DocType: Bank Reconciliation,Account Currency,Reikningur Gjaldmiðill
apps/erpnext/erpnext/accounts/general_ledger.py +142,Please mention Round Off Account in Company,Vinsamlegast nefna umferð á reikning í félaginu
DocType: Purchase Receipt,Range,Range
DocType: Supplier,Default Payable Accounts,Sjálfgefin greiðast reikningar
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,Starfsmaður {0} er ekki virkur eða er ekki til
DocType: Fee Structure,Components,Hluti
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +250,Please enter Asset Category in Item {0},Vinsamlegast sláðu eignaflokki í lið {0}
DocType: Quality Inspection Reading,Reading 6,lestur 6
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +863,Cannot {0} {1} {2} without any negative outstanding invoice,Get ekki {0} {1} {2} án neikvætt framúrskarandi Reikningar
DocType: Purchase Invoice Advance,Purchase Invoice Advance,Kaupa Reikningar Advance
DocType: Hub Settings,Sync Now,Sync Nú
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 færslu er ekki hægt að tengja með {1}
apps/erpnext/erpnext/config/accounts.py +215,Define budget for a financial year.,Skilgreina fjárhagsáætlun fyrir fjárhagsár.
DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Default Bank / Cash reikningur verður sjálfkrafa uppfærð í POS Invoice þegar þetta háttur er valinn.
DocType: Lead,LEAD-,aukinni eftirvinnu sem skapar
DocType: Employee,Permanent Address Is,Varanleg Heimilisfang er
DocType: Production Order Operation,Operation completed for how many finished goods?,Operation lokið fyrir hversu mörgum fullunnum vörum?
apps/erpnext/erpnext/public/js/setup_wizard.js +167,The Brand,The Brand
DocType: Employee,Exit Interview Details,Hætta Viðtal Upplýsingar
DocType: Item,Is Purchase Item,Er Purchase Item
DocType: Asset,Purchase Invoice,kaup Invoice
DocType: Stock Ledger Entry,Voucher Detail No,Skírteini Detail No
apps/erpnext/erpnext/accounts/page/pos/pos.js +719,New Sales Invoice,Nýr reikningur
DocType: Stock Entry,Total Outgoing Value,Alls Outgoing Value
apps/erpnext/erpnext/public/js/account_tree_grid.js +225,Opening Date and Closing Date should be within same Fiscal Year,Opnun Dagsetning og lokadagur ætti að vera innan sama reikningsár
DocType: Lead,Request for Information,Beiðni um upplýsingar
apps/erpnext/erpnext/accounts/page/pos/pos.js +733,Sync Offline Invoices,Sync Offline Reikningar
DocType: Payment Request,Paid,greiddur
DocType: Program Fee,Program Fee,program Fee
DocType: Salary Slip,Total in words,Samtals í orðum
DocType: Material Request Item,Lead Time Date,Lead Time Dagsetning
DocType: Guardian,Guardian Name,Guardian Name
DocType: Cheque Print Template,Has Print Format,Hefur prenta sniði
DocType: Employee Loan,Sanctioned,bundnar
apps/erpnext/erpnext/accounts/page/pos/pos.js +72, is mandatory. Maybe Currency Exchange record is not created for ,er nauðsynlegur. Kannski gjaldeyri færsla er ekki búin að
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +111,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Vinsamlegast tilgreinið Serial Nei fyrir lið {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +642,"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.","Fyrir &quot;vara búnt &#39;atriði, Lager, Serial Nei og Batch No verður að teljast úr&#39; Pökkun lista &#39;töflunni. Ef Warehouse og Batch No eru sömu fyrir alla pökkun atriði fyrir hvaða &quot;vara búnt &#39;lið, sem gildin má færa í helstu atriði borðið, gildi verða afrituð á&#39; Pökkun lista &#39;borð."
DocType: Job Opening,Publish on website,Birta á vefsíðu
apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Sendingar til viðskiptavina.
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +622,Supplier Invoice Date cannot be greater than Posting Date,Birgir Invoice Dagsetning má ekki vera meiri en Staða Dagsetning
DocType: Purchase Invoice Item,Purchase Order Item,Purchase Order Item
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +130,Indirect Income,Óbein Tekjur
DocType: Student Attendance Tool,Student Attendance Tool,Student Aðsókn Tool
DocType: Cheque Print Template,Date Settings,Dagsetning Stillingar
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,dreifni
,Company Name,nafn fyrirtækis
DocType: SMS Center,Total Message(s),Total Message (s)
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +843,Select Item for Transfer,Veldu Atriði til flutnings
DocType: Purchase Invoice,Additional Discount Percentage,Viðbótarupplýsingar Afsláttur Hlutfall
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Skoða lista yfir öll hjálparefni myndbönd
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Veldu yfirmaður reikning bankans þar stöðva var afhent.
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Leyfa notanda að breyta gjaldskránni Rate í viðskiptum
DocType: Pricing Rule,Max Qty,max Magn
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","Row {0}: Invoice {1} er ógild, það gæti verið hætt / er ekki fyrir hendi. \ Sláðu inn gilt Invoice"
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}: Greiðsla gegn sölu / Purchase Order ætti alltaf að vera merkt sem fyrirfram
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +16,Chemical,Chemical
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Default Bank / Cash reikningur verður sjálfkrafa uppfærð í laun dagbókarfærslu þegar þessi háttur er valinn.
DocType: BOM,Raw Material Cost(Company Currency),Raw Material Kostnaður (Company Gjaldmiðill)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +732,All items have already been transferred for this Production Order.,Allir hlutir hafa þegar verið flutt í þessari framleiðslu Order.
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Row # {0}: Gengi má ekki vera hærra en hlutfallið sem notað er í {1} {2}
apps/erpnext/erpnext/public/js/setup_wizard.js +304,Meter,Meter
DocType: Workstation,Electricity Cost,rafmagn Kostnaður
DocType: HR Settings,Don't send Employee Birthday Reminders,Ekki senda starfsmaður afmælisáminningar
DocType: Item,Inspection Criteria,Skoðun Viðmið
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,framseldir
DocType: BOM Website Item,BOM Website Item,BOM Website Item
apps/erpnext/erpnext/public/js/setup_wizard.js +168,Upload your letter head and logo. (you can edit them later).,Hlaða bréf höfuðið og merki. (Þú getur breytt þeim síðar).
DocType: Timesheet Detail,Bill,Bill
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +85,Next Depreciation Date is entered as past date,Næsta Afskriftir Date er færður sem síðasta dags
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +170,White,White
DocType: SMS Center,All Lead (Open),Allt Lead (Open)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +230,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Row {0}: Magn er ekki í boði fyrir {4} í vöruhús {1} á að senda sinn færslunnar ({2} {3})
DocType: Purchase Invoice,Get Advances Paid,Fá Framfarir Greiddur
DocType: Item,Automatically Create New Batch,Búðu til nýjan hóp sjálfkrafa
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +762,Make ,gera
DocType: Student Admission,Admission Start Date,Aðgangseyrir Start Date
DocType: Journal Entry,Total Amount in Words,Heildarfjárhæð orðum
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.,Það var villa. Ein líkleg ástæða gæti verið að þú hefur ekki vistað mynd. Vinsamlegast hafðu samband support@erpnext.com ef vandamálið er viðvarandi.
apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Karfan mín
apps/erpnext/erpnext/controllers/selling_controller.py +155,Order Type must be one of {0},Order Type verður að vera einn af {0}
DocType: Lead,Next Contact Date,Næsta samband við þann
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +35,Opening Qty,opnun Magn
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +449,Please enter Account for Change Amount,Vinsamlegast sláðu inn reikning fyrir Change Upphæð
DocType: Student Batch Name,Student Batch Name,Student Hópur Name
DocType: Holiday List,Holiday List Name,Holiday List Nafn
DocType: Repayment Schedule,Balance Loan Amount,Balance lánsfjárhæð
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.js +13,Schedule Course,Dagskrá Námskeið
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +186,Stock Options,Kaupréttir
DocType: Journal Entry Account,Expense Claim,Expense Krafa
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +245,Do you really want to restore this scrapped asset?,Viltu virkilega að endurheimta rifið eign?
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +259,Qty for {0},Magn {0}
DocType: Leave Application,Leave Application,Leave Umsókn
apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Skildu Úthlutun Tól
DocType: Leave Block List,Leave Block List Dates,Skildu Block Listi Dagsetningar
DocType: Workstation,Net Hour Rate,Net Hour Rate
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Landað Kostnaður Kvittun
DocType: Company,Default Terms,Sjálfgefin Skilmálar
DocType: Packing Slip Item,Packing Slip Item,Pökkun Slip Item
DocType: Purchase Invoice,Cash/Bank Account,Cash / Bank Account
apps/erpnext/erpnext/public/js/queries.js +88,Please specify a {0},Tilgreindu {0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Removed items with no change in quantity or value.,Fjarlægðar atriði með engin breyting á magni eða verðmæti.
DocType: Delivery Note,Delivery To,Afhending Til
apps/erpnext/erpnext/stock/doctype/item/item.py +637,Attribute table is mandatory,Eiginleiki borð er nauðsynlegur
DocType: Production Planning Tool,Get Sales Orders,Fá sölu skipunum
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +67,{0} can not be negative,{0} er ekki hægt að neikvæð
apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +11,Discount,afsláttur
DocType: Asset,Total Number of Depreciations,Heildarfjöldi Afskriftir
DocType: Sales Invoice Item,Rate With Margin,Meta með skák
DocType: Workstation,Wages,laun
DocType: Project,Internal,innri
DocType: Task,Urgent,Urgent
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +149,Please specify a valid Row ID for row {0} in table {1},Vinsamlegast tilgreindu gilt Row skírteini fyrir röð {0} í töflunni {1}
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Fara á Desktop og byrja að nota ERPNext
DocType: Item,Manufacturer,framleiðandi
DocType: Landed Cost Item,Purchase Receipt Item,Kvittun Item
DocType: Purchase Receipt,PREC-RET-,PREC-RET-
DocType: POS Profile,Sales Invoice Payment,Velta Invoice Greiðsla
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Frátekin Warehouse í Velta Order / Finished Goods Warehouse
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +73,Selling Amount,selja Upphæð
DocType: Repayment Schedule,Interest Amount,vextir Upphæð
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +121,You are the Expense Approver for this record. Please Update the 'Status' and Save,Þú ert kostnað samþykkjari fyrir þessa færslu. Uppfærðu &#39;Staða&#39; og Vista
DocType: Serial No,Creation Document No,Creation Skjal nr
DocType: Issue,Issue,Mál
DocType: Asset,Scrapped,rifið
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account does not match with Company,Reikningur passar ekki við félagið
apps/erpnext/erpnext/config/stock.py +195,"Attributes for Item Variants. e.g Size, Color etc.","Eiginleiki fyrir Liður Útgáfur. td stærð, liti o.fl."
DocType: Purchase Invoice,Returns,Skil
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 +196,Serial No {0} is under maintenance contract upto {1},Serial Nei {0} er undir viðhald samning uppí {1}
apps/erpnext/erpnext/config/hr.py +35,Recruitment,Ráðningar
DocType: Lead,Organization Name,nafn samtaka
DocType: Tax Rule,Shipping State,Sendingar State
,Projected Quantity as Source,Áætlaðar Magn eins Source
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +59,Item must be added using 'Get Items from Purchase Receipts' button,Atriði verður að bæta með því að nota &quot;fá atriði úr greiðslukvittanir &#39;hnappinn
DocType: Employee,A-,A-
DocType: Production Planning Tool,Include non-stock items,Fela ekki lager atriði
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +115,Sales Expenses,sölukostnaður
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Standard Buying
DocType: GL Entry,Against,gegn
DocType: Item,Default Selling Cost Center,Sjálfgefið Selja Kostnaður Center
DocType: Sales Partner,Implementation Partner,framkvæmd Partner
apps/erpnext/erpnext/accounts/page/pos/pos.js +1499,ZIP Code,Póstnúmer
apps/erpnext/erpnext/controllers/selling_controller.py +265,Sales Order {0} is {1},Velta Order {0} er {1}
DocType: Opportunity,Contact Info,Contact Info
apps/erpnext/erpnext/config/stock.py +310,Making Stock Entries,Gerð lager færslur
DocType: Packing Slip,Net Weight UOM,Net Weight UOM
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +18,{0} Results,{0} Úrslit
DocType: Item,Default Supplier,Sjálfgefið Birgir
DocType: Manufacturing Settings,Over Production Allowance Percentage,Yfir Production losunarheimilda Hlutfall
DocType: Employee Loan,Repayment Schedule,endurgreiðsla Dagskrá
DocType: Shipping Rule Condition,Shipping Rule Condition,Sendingar Regla Ástand
DocType: Holiday List,Get Weekly Off Dates,Fáðu vikulega Off Dagsetningar
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Lokadagur má ekki vera minna en Start Date
DocType: Sales Person,Select company name first.,Select nafn fyrirtækis fyrst.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +154,Dr,dr
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Tilvitnanir berast frá birgja.
apps/erpnext/erpnext/controllers/selling_controller.py +22,To {0} | {1} {2},Til {0} | {1} {2}
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Meðalaldur
DocType: School Settings,Attendance Freeze Date,Viðburður Frystingardagur
DocType: Opportunity,Your sales person who will contact the customer in future,Sala þinn sá sem mun hafa samband við viðskiptavininn í framtíðinni
apps/erpnext/erpnext/public/js/setup_wizard.js +266,List a few of your suppliers. They could be organizations or individuals.,Listi nokkrar af birgja þína. Þeir gætu verið stofnanir eða einstaklingar.
apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Sjá allar vörur
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Lágmarksstigleiki (dagar)
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +59,All BOMs,Allir BOMs
DocType: Company,Default Currency,sjálfgefið mynt
DocType: Expense Claim,From Employee,frá starfsmanni
apps/erpnext/erpnext/controllers/accounts_controller.py +417,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Viðvörun: Kerfi mun ekki stöðva overbilling síðan upphæð fyrir lið {0} í {1} er núll
DocType: Journal Entry,Make Difference Entry,Gera Mismunur færslu
DocType: Upload Attendance,Attendance From Date,Aðsókn Frá Dagsetning
DocType: Appraisal Template Goal,Key Performance Area,Key Performance Area
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +54,Transportation,samgöngur
apps/erpnext/erpnext/controllers/item_variant.py +92,Invalid Attribute,Ógilt Attribute
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +201,{0} {1} must be submitted,{0} {1} Leggja skal fram
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +146,Quantity must be less than or equal to {0},Magn verður að vera minna en eða jafnt og {0}
DocType: SMS Center,Total Characters,Samtals Stafir
apps/erpnext/erpnext/controllers/buying_controller.py +154,Please select BOM in BOM field for Item {0},Vinsamlegast veldu BOM á BOM sviði í lið {0}
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form Reikningur Detail
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Greiðsla Sættir Invoice
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +42,Contribution %,framlag%
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Fyrirtæki skráningarnúmer til viðmiðunar. Tax tölur o.fl.
DocType: Sales Partner,Distributor,dreifingaraðili
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Shopping Cart Shipping Rule
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +224,Production Order {0} must be cancelled before cancelling this Sales Order,Framleiðslu Order {0} verður lokað áður en hætta þessu Velta Order
apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Vinsamlegast settu &#39;Virkja Viðbótarupplýsingar afslátt&#39;
,Ordered Items To Be Billed,Pantaði Items verður innheimt
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Frá Range þarf að vera minna en við úrval
DocType: Global Defaults,Global Defaults,Global Vanskil
apps/erpnext/erpnext/projects/doctype/project/project.py +202,Project Collaboration Invitation,Project Samvinna Boð
DocType: Salary Slip,Deductions,frádráttur
DocType: Leave Allocation,LAL/,LAL /
apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Start Ár
DocType: Purchase Invoice,Start date of current invoice's period,Upphafsdagur tímabils núverandi reikningi er
DocType: Salary Slip,Leave Without Pay,Leyfi án launa
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,Capacity Planning Error,Getu Planning Villa
,Trial Balance for Party,Trial Balance fyrir aðila
DocType: Lead,Consultant,Ráðgjafi
DocType: Salary Slip,Earnings,Hagnaður
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +390,Finished Item {0} must be entered for Manufacture type entry,Lokið Item {0} verður inn fyrir Framleiðsla tegund færslu
apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Opnun Bókhald Balance
DocType: Sales Invoice Advance,Sales Invoice Advance,Velta Invoice Advance
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +548,Nothing to request,Ekkert til að biðja
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Annar Budget met &#39;{0}&#39; er þegar til á móti {1} &#39;{2}&#39; fyrir reikningsár {3}
apps/erpnext/erpnext/projects/doctype/task/task.py +40,'Actual Start Date' can not be greater than 'Actual End Date',&quot;Raunbyrjunardagsetning &#39;má ekki vera meiri en&#39; Raunveruleg lokadagur&quot;
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +79,Management,Stjórn
DocType: Cheque Print Template,Payer Settings,greiðandi Stillingar
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""","Þetta verður bætt við Item Code afbrigði. Til dæmis, ef skammstöfun er &quot;SM&quot;, og hluturinn kóða er &quot;T-bolur&quot;, hluturinn kóðann um afbrigði verður &quot;T-bolur-SM&quot;"
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Net Borga (í orðum) verður sýnileg þegar þú hefur vistað Laun Slip.
DocType: Purchase Invoice,Is Return,er aftur
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +767,Return / Debit Note,Return / skuldfærslu Note
DocType: Price List Country,Price List Country,Verðskrá Country
DocType: Item,UOMs,UOMs
apps/erpnext/erpnext/stock/utils.py +182,{0} valid serial nos for Item {1},{0} gild raðnúmer nos fyrir lið {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Item Code er ekki hægt að breyta fyrir Raðnúmer
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +24,POS Profile {0} already created for user: {1} and company {2},POS Profile {0} þegar búin að notanda: {1} og fyrirtæki {2}
DocType: Sales Invoice Item,UOM Conversion Factor,UOM viðskipta Factor
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +24,Please enter Item Code to get Batch Number,Vinsamlegast sláðu Item Code til að fá lotunúmer
DocType: Stock Settings,Default Item Group,Sjálfgefið Item Group
DocType: Employee Loan,Partially Disbursed,hluta ráðstafað
apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Birgir gagnagrunni.
DocType: Account,Balance Sheet,Efnahagsreikningur
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +704,Cost Center For Item with Item Code ',Kostnaður Center For lið með Item Code &#39;
apps/erpnext/erpnext/accounts/page/pos/pos.js +2340,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",Greiðsla Mode er ekki stillt. Vinsamlegast athugaðu hvort reikningur hefur verið sett á Mode Greiðslur eða POS Profile.
DocType: Opportunity,Your sales person will get a reminder on this date to contact the customer,velta manneskja mun fá áminningu á þessari dagsetningu til að hafa samband við viðskiptavini
apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Sama atriði er ekki hægt inn mörgum sinnum.
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","Frekari reikninga er hægt að gera undir Hópar, en færslur er hægt að gera á móti non-hópa"
DocType: Lead,Lead,Lead
DocType: Email Digest,Payables,skammtímaskuldir
DocType: Course,Course Intro,Auðvitað Um
apps/erpnext/erpnext/stock/doctype/batch/batch.js +85,Stock Entry {0} created,Stock Entry {0} búin
apps/erpnext/erpnext/controllers/buying_controller.py +290,Row #{0}: Rejected Qty can not be entered in Purchase Return,Row # {0}: Hafnað Magn er ekki hægt að færa í Purchase aftur
,Purchase Order Items To Be Billed,Purchase Order Items verður innheimt
DocType: Purchase Invoice Item,Net Rate,Net Rate
DocType: Purchase Invoice Item,Purchase Invoice Item,Kaupa Reikningar Item
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +57,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Lager Ledger Entries og GL Færslur eru endurbirt fyrir valin Purchase Kvittanir
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Atriði 1
DocType: Holiday,Holiday,Holiday
DocType: Support Settings,Close Issue After Days,Loka Issue Eftir daga
DocType: Leave Control Panel,Leave blank if considered for all branches,Skildu eftir autt ef það er talið að öllum greinum
DocType: Bank Guarantee,Validity in Days,Gildi í dögum
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-form er ekki fyrir Invoice: {0}
DocType: Payment Reconciliation,Unreconciled Payment Details,Unreconciled Upplýsingar Greiðsla
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Order Count
DocType: Global Defaults,Current Fiscal Year,Yfirstandandi reikningsári
DocType: Purchase Order,Group same items,Group sömu atriði
DocType: Global Defaults,Disable Rounded Total,Slökkva á Ávalur Samtals
DocType: Employee Loan Application,Repayment Info,endurgreiðsla Upplýsingar
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,&#39;Færslur&#39; má ekki vera autt
apps/erpnext/erpnext/utilities/transaction_base.py +81,Duplicate row {0} with same {1},Afrit róður {0} með sama {1}
,Trial Balance,Trial Balance
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +416,Fiscal Year {0} not found,Reikningsár {0} fannst ekki
apps/erpnext/erpnext/config/hr.py +296,Setting up Employees,Setja upp Starfsmenn
DocType: Sales Order,SO-,SO-
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +157,Please select prefix first,Vinsamlegast veldu forskeyti fyrst
DocType: Employee,O-,O-
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +151,Research,Rannsókn
DocType: Maintenance Visit Purpose,Work Done,vinnu
apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,Vinsamlegast tilgreindu að minnsta kosti einn eiginleiki í þeim einkennum töflunni
DocType: Announcement,All Students,Allir nemendur
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +45,Item {0} must be a non-stock item,Liður {0} verður að a non-birgðir atriði
apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Skoða Ledger
DocType: Grading Scale,Intervals,millibili
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,elstu
apps/erpnext/erpnext/stock/doctype/item/item.py +510,"An Item Group exists with same name, please change the item name or rename the item group","An Item Group til staðar með sama nafni, vinsamlegast breyta hlutinn nafni eða endurnefna atriði hópinn"
apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +46,Student Mobile No.,Student Mobile No.
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +475,Rest Of The World,Rest Of The World
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,The Item {0} getur ekki Hópur
,Budget Variance Report,Budget Dreifni Report
DocType: Salary Slip,Gross Pay,Gross Pay
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: Activity Type is mandatory.,Row {0}: Activity Type er nauðsynlegur.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +164,Dividends Paid,arður Greiddur
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,bókhald Ledger
DocType: Stock Reconciliation,Difference Amount,munurinn Upphæð
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +170,Retained Earnings,Óráðstafað eigið fé
DocType: Vehicle Log,Service Detail,þjónusta Detail
DocType: BOM,Item Description,Lýsing á hlut
DocType: Student Sibling,Student Sibling,Student systkini
DocType: Purchase Invoice,Is Recurring,er Fastir
DocType: Purchase Invoice,Supplied Items,Meðfylgjandi Items
DocType: Student,STUD.,STUD.
DocType: Production Order,Qty To Manufacture,Magn To Framleiðsla
DocType: Email Digest,New Income,ný Tekjur
DocType: School Settings,School Settings,Skólastillingar
DocType: Buying Settings,Maintain same rate throughout purchase cycle,Halda sama hlutfall allan kaup hringrás
DocType: Opportunity Item,Opportunity Item,tækifæri Item
,Student and Guardian Contact Details,Student og Guardian Tengiliðir Upplýsingar
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +39,Row {0}: For supplier {0} Email Address is required to send email,Row {0}: Fyrir birgja {0} Netfang þarf að senda tölvupóst
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +70,Temporary Opening,tímabundin Opening
,Employee Leave Balance,Starfsmaður Leave Balance
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Stöðunni á reikningnum {0} verður alltaf að vera {1}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +178,Valuation Rate required for Item in row {0},Verðmat Gefa þarf fyrir lið í röð {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +328,Example: Masters in Computer Science,Dæmi: Masters í tölvunarfræði
DocType: Purchase Invoice,Rejected Warehouse,hafnað Warehouse
DocType: GL Entry,Against Voucher,Against Voucher
DocType: Item,Default Buying Cost Center,Sjálfgefið Buying Kostnaður Center
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.","Til að fá það besta út úr ERPNext, mælum við með að þú að taka nokkurn tíma og horfa á þessi hjálp vídeó."
apps/erpnext/erpnext/accounts/page/pos/pos.js +73, to ,að
DocType: Item,Lead Time in days,Lead Time í dögum
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Viðskiptaskuldir Yfirlit
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +332,Payment of salary from {0} to {1},Greiðsla launum frá {0} til {1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Ekki heimild til að breyta frosinn reikning {0}
DocType: Journal Entry,Get Outstanding Invoices,Fá útistandandi reikninga
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +64,Sales Order {0} is not valid,Velta Order {0} er ekki gilt
apps/erpnext/erpnext/utilities/activation.py +89,Purchase orders help you plan and follow up on your purchases,Kaup pantanir hjálpa þér að skipuleggja og fylgja eftir kaupum þínum
apps/erpnext/erpnext/setup/doctype/company/company.py +212,"Sorry, companies cannot be merged","Því miður, fyrirtæki geta ekki vera sameinuð"
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +134,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",Heildarkostnaður Issue / Transfer magn {0} í efni Beiðni {1} \ má ekki vera meiri en óskað magn {2} fyrir lið {3}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +159,Small,Lítil
DocType: Employee,Employee Number,starfsmaður Number
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +65,Case No(s) already in use. Try from Case No {0},Case Nei (s) þegar í notkun. Prófaðu frá máli nr {0}
DocType: Project,% Completed,% Lokið
,Invoiced Amount (Exculsive Tax),Upphæð á reikningi (Exculsive Tax)
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Liður 2
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +79,Account head {0} created,Reikningur höfuð {0} búin
DocType: Supplier,SUPP-,SUPP-
DocType: Training Event,Training Event,Þjálfun Event
DocType: Item,Auto re-order,Auto endurraða
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,alls Náð
DocType: Employee,Place of Issue,Útgáfustaður
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +63,Contract,Samningur
DocType: Email Digest,Add Quote,Bæta Quote
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +860,UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion þáttur sem þarf til UOM: {0} í lið: {1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +90,Indirect Expenses,óbeinum kostnaði
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +83,Row {0}: Qty is mandatory,Row {0}: Magn er nauðsynlegur
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Landbúnaður
apps/erpnext/erpnext/accounts/page/pos/pos.js +724,Sync Master Data,Sync Master Data
apps/erpnext/erpnext/public/js/setup_wizard.js +288,Your Products or Services,Vörur eða þjónustu
DocType: Mode of Payment,Mode of Payment,Háttur á greiðslu
apps/erpnext/erpnext/stock/doctype/item/item.py +180,Website Image should be a public file or website URL,Vefsíða Image ætti að vera opinber skrá eða vefslóð
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.,Þetta er rót atriði hóp og ekki hægt að breyta.
DocType: Journal Entry Account,Purchase Order,Pöntun
DocType: Vehicle,Fuel UOM,eldsneyti UOM
DocType: Warehouse,Warehouse Contact Info,Warehouse Contact Info
DocType: Payment Entry,Write Off Difference Amount,Skrifaðu Off Mismunur Upphæð
DocType: Purchase Invoice,Recurring Type,Fastir Type
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +394,"{0}: Employee email not found, hence email not sent","{0}: Starfsmaður tölvupósti fannst ekki, þess vegna email ekki sent"
DocType: Item,Foreign Trade Details,Foreign Trade Upplýsingar
DocType: Email Digest,Annual Income,Árleg innkoma
DocType: Serial No,Serial No Details,Serial Nei Nánar
DocType: Purchase Invoice Item,Item Tax Rate,Liður Skatthlutfall
DocType: Student Group Student,Group Roll Number,Group Roll Number
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry","Fyrir {0}, aðeins kredit reikninga er hægt að tengja við aðra gjaldfærslu"
apps/erpnext/erpnext/projects/doctype/project/project.py +70,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Alls öllum verkefni lóðum skal vera 1. Stilltu vigta allar verkefni verkefni í samræmi við
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +558,Delivery Note {0} is not submitted,Afhending Note {0} er ekki lögð
apps/erpnext/erpnext/stock/get_item_details.py +141,Item {0} must be a Sub-contracted Item,Liður {0} verður að vera Sub-dregist Item
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +41,Capital Equipments,Capital útbúnaður
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +31,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Verðlagning Regla er fyrst valið byggist á &#39;Virkja Á&#39; sviði, sem getur verið Item, Item Group eða Brand."
DocType: Hub Settings,Seller Website,Seljandi Website
DocType: Item,ITEM-,ITEM-
apps/erpnext/erpnext/controllers/selling_controller.py +148,Total allocated percentage for sales team should be 100,Samtals úthlutað hlutfall fyrir Söluteymi ætti að vera 100
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +112,Production Order status is {0},Framleiðsla Order staðan er {0}
DocType: Appraisal Goal,Goal,Markmið
DocType: Sales Invoice Item,Edit Description,Breyta Lýsing
,Team Updates,Team uppfærslur
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +778,For Supplier,fyrir Birgir
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Uppsetning reiknings Tegund hjálpar í því að velja þennan reikning í viðskiptum.
DocType: Purchase Invoice,Grand Total (Company Currency),Grand Total (Company Gjaldmiðill)
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Búa prenta sniði
apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},Fékk ekki fundið neitt atriði sem heitir {0}
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,alls Outgoing
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""",Það getur aðeins verið einn Shipping Rule Ástand með 0 eða autt gildi fyrir &quot;to Value&quot;
DocType: Authorization Rule,Transaction,Færsla
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Ath: Þessi Kostnaður Center er Group. Get ekki gert bókhaldsfærslum gegn hópum.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126,Child warehouse exists for this warehouse. You can not delete this warehouse.,Barnið vöruhús er til fyrir þetta vöruhús. Þú getur ekki eytt þessari vöruhús.
DocType: Item,Website Item Groups,Vefsíða Item Hópar
DocType: Purchase Invoice,Total (Company Currency),Total (Company Gjaldmiðill)
apps/erpnext/erpnext/stock/utils.py +177,Serial number {0} entered more than once,Raðnúmer {0} inn oftar en einu sinni
DocType: Depreciation Schedule,Journal Entry,Dagbókarfærsla
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +78,{0} items in progress,{0} atriði í gangi
DocType: Workstation,Workstation Name,Workstation Name
DocType: Grading Scale Interval,Grade Code,bekk Code
DocType: POS Item Group,POS Item Group,POS Item Group
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Sendu Digest:
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +516,BOM {0} does not belong to Item {1},BOM {0} ekki tilheyra lið {1}
DocType: Sales Partner,Target Distribution,Target Dreifing
DocType: Salary Slip,Bank Account No.,Bankareikningur nr
DocType: Naming Series,This is the number of the last created transaction with this prefix,Þetta er fjöldi síðustu búin færslu með þessu forskeyti
DocType: Quality Inspection Reading,Reading 8,lestur 8
DocType: Sales Partner,Agent,Agent
DocType: Purchase Invoice,Taxes and Charges Calculation,Skattar og gjöld Útreikningur
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Bókfært eignaaukning sjálfkrafa
DocType: BOM Operation,Workstation,Workstation
DocType: Request for Quotation Supplier,Request for Quotation Supplier,Beiðni um Tilvitnun Birgir
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +116,Hardware,Vélbúnaður
DocType: Sales Order,Recurring Upto,Fastir uppí
DocType: Attendance,HR Manager,HR Manager
apps/erpnext/erpnext/accounts/party.py +164,Please select a Company,Vinsamlegast veldu Company
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +54,Privilege Leave,Privilege Leave
DocType: Purchase Invoice,Supplier Invoice Date,Birgir Dagsetning reiknings
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Þú þarft að virkja Shopping Cart
DocType: Payment Entry,Writeoff,Afskrifa
DocType: Appraisal Template Goal,Appraisal Template Goal,Úttekt Snið Goal
DocType: Salary Component,Earning,earnings
DocType: Purchase Invoice,Party Account Currency,Party Reikningur Gjaldmiðill
,BOM Browser,BOM Browser
DocType: Purchase Taxes and Charges,Add or Deduct,Bæta eða draga
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +80,Overlapping conditions found between:,Skarast skilyrði fundust milli:
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,Gegn Journal Entry {0} er þegar leiðrétt gagnvart einhverjum öðrum skírteini
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Pöntunin Value
apps/erpnext/erpnext/demo/setup/setup_data.py +322,Food,Matur
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Ageing Range 3
DocType: Maintenance Schedule Item,No of Visits,Engin heimsókna
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +113,Mark Attendence,Mark Attendence
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +166,Maintenance Schedule {0} exists against {1},Viðhaldsáætlun {0} er til staðar gegn {1}
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +32,Enrolling student,innritast nemandi
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Gjaldmiðill lokun reiknings skal vera {0}
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Summa stig fyrir allar markmiðum ætti að vera 100. Það er {0}
DocType: Project,Start and End Dates,Upphafs- og lokadagsetningar
,Delivered Items To Be Billed,Afhent Items verður innheimt
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Open BOM {0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Warehouse er ekki hægt að breyta fyrir Raðnúmer
DocType: Authorization Rule,Average Discount,Meðal Afsláttur
DocType: Purchase Invoice Item,UOM,UOM
DocType: Rename Tool,Utilities,Utilities
DocType: Purchase Invoice Item,Accounting,bókhald
DocType: Employee,EMP/,EMP /
DocType: Asset,Depreciation Schedules,afskriftir Skrár
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Umsókn tímabil getur ekki verið úti leyfi úthlutun tímabil
DocType: Activity Cost,Projects,verkefni
DocType: Payment Request,Transaction Currency,Færsla Gjaldmiðill
apps/erpnext/erpnext/controllers/buying_controller.py +25,From {0} | {1} {2},Frá {0} | {1} {2}
DocType: Production Order Operation,Operation Description,Operation Lýsing
DocType: Item,Will also apply to variants,Mun einnig eiga við afbrigði
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.,Get ekki breytt Fiscal Year upphafsdagur og reikningsár lokadag þegar Fiscal Year er vistuð.
DocType: Quotation,Shopping Cart,Innkaupakerra
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Avg Daily Outgoing
DocType: POS Profile,Campaign,herferð
DocType: Supplier,Name and Type,Nafn og tegund
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +56,Approval Status must be 'Approved' or 'Rejected',Samþykki Staða verður &quot;Samþykkt&quot; eða &quot;Hafnað &#39;
DocType: Purchase Invoice,Contact Person,Tengiliður
apps/erpnext/erpnext/projects/doctype/task/task.py +37,'Expected Start Date' can not be greater than 'Expected End Date',&quot;Bjóst Start Date &#39;má ekki vera meiri en&#39; Bjóst Lokadagur &#39;
DocType: Course Scheduling Tool,Course End Date,Auðvitað Lokadagur
DocType: Holiday List,Holidays,Holidays
DocType: Sales Order Item,Planned Quantity,Áætlaðir Magn
DocType: Purchase Invoice Item,Item Tax Amount,Liður Tax Upphæð
DocType: Item,Maintain Stock,halda lager
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +211,Stock Entries already created for Production Order ,Lager Færslur nú þegar búið til framleiðslu Order
DocType: Employee,Prefered Email,Ákjósanleg Email
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Net Breyting á fast eign
DocType: Leave Control Panel,Leave blank if considered for all designations,Skildu eftir autt ef það er talið fyrir alla heita
apps/erpnext/erpnext/accounts/doctype/account/account.py +176,Warehouse is mandatory for non group Accounts of type Stock,Warehouse er nauðsynlegur fyrir utan reikninga hópa var gerð lager
apps/erpnext/erpnext/controllers/accounts_controller.py +673,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Gjald af gerðinni &#39;Raunveruleg&#39; í röð {0} er ekki að vera með í Item Rate
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +260,Max: {0},Max: {0}
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,frá DATETIME
DocType: Email Digest,For Company,Company
apps/erpnext/erpnext/config/support.py +17,Communication log.,Samskipti þig.
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +151,"Request for Quotation is disabled to access from portal, for more check portal settings.","Beiðni um tilvitnun er óvirk til að fá aðgang frá vefsíðunni, fyrir meira Check vefgáttinni stillingar."
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Buying Amount,Kaup Upphæð
DocType: Sales Invoice,Shipping Address Name,Sendingar Address Nafn
apps/erpnext/erpnext/accounts/doctype/account/account.js +49,Chart of Accounts,Mynd reikninga
DocType: Material Request,Terms and Conditions Content,Skilmálar og skilyrði Content
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +575,cannot be greater than 100,getur ekki verið meiri en 100
apps/erpnext/erpnext/stock/doctype/item/item.py +689,Item {0} is not a stock Item,Liður {0} er ekki birgðir Item
DocType: Maintenance Visit,Unscheduled,unscheduled
DocType: Employee,Owned,eigu
DocType: Salary Detail,Depends on Leave Without Pay,Fer um leyfi án launa
DocType: Pricing Rule,"Higher the number, higher the priority","Hærri sem talan, hærri forgang"
,Purchase Invoice Trends,Kaupa Reikningar Trends
DocType: Employee,Better Prospects,betri horfur
apps/erpnext/erpnext/stock/doctype/batch/batch.py +106,"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",Row # {0}: Batch {1} hefur aðeins {2} magn. Vinsamlegast veldu annað lotu sem hefur {3} magn í boði eða skipt röðina í margar línur til að afhenda / gefa út úr mörgum lotum
DocType: Vehicle,License Plate,Númeraplata
DocType: Appraisal,Goals,mörk
DocType: Warranty Claim,Warranty / AMC Status,Ábyrgð í / AMC Staða
,Accounts Browser,reikningar Browser
DocType: Payment Entry Reference,Payment Entry Reference,Greiðsla Entry Tilvísun
DocType: GL Entry,GL Entry,GL Entry
DocType: HR Settings,Employee Settings,Employee Stillingar
,Batch-Wise Balance History,Hópur-Wise Balance Saga
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Prenta uppfærðar í viðkomandi prenta sniði
DocType: Package Code,Package Code,pakki Code
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +67,Apprentice,lærlingur
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Neikvætt Magn er ekki leyfð
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 smáatriði borð sóttu meistara lið sem streng og geyma á þessu sviði. Notað fyrir skatta og gjöld
apps/erpnext/erpnext/hr/doctype/employee/employee.py +154,Employee cannot report to himself.,Starfsmaður getur ekki skýrslu við sjálfan sig.
DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Ef reikningur er frosinn, eru færslur leyft að afmörkuðum notendum."
DocType: Email Digest,Bank Balance,Bank Balance
apps/erpnext/erpnext/accounts/party.py +227,Accounting Entry for {0}: {1} can only be made in currency: {2},Bókhald Entry fyrir {0}: {1} Aðeins er hægt að gera í gjaldmiðli: {2}
DocType: Job Opening,"Job profile, qualifications required etc.","Job uppsetningu, hæfi sem krafist o.fl."
DocType: Journal Entry Account,Account Balance,Staða reiknings
apps/erpnext/erpnext/config/accounts.py +185,Tax Rule for transactions.,Tax Regla fyrir viðskiptum.
DocType: Rename Tool,Type of document to rename.,Tegund skjals til að endurnefna.
apps/erpnext/erpnext/public/js/setup_wizard.js +307,We buy this Item,Við þurfum að kaupa þessa vöru
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1}: Viðskiptavini er krafist móti óinnheimt reikninginn {2}
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Samtals Skattar og gjöld (Company gjaldmiðli)
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Sýna P &amp; unclosed fjárhagsári er L jafnvægi
DocType: Shipping Rule,Shipping Account,Sendingar Account
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1}: Account {2} er óvirkur
apps/erpnext/erpnext/utilities/activation.py +80,Make Sales Orders to help you plan your work and deliver on-time,Gera Velta Pantanir til að hjálpa þér að skipuleggja vinnu þína og skila á tíma
DocType: Quality Inspection,Readings,Upplestur
DocType: Stock Entry,Total Additional Costs,Samtals viðbótarkostnað
DocType: Course Schedule,SH,SH
DocType: BOM,Scrap Material Cost(Company Currency),Rusl efniskostnaði (Company Gjaldmiðill)
apps/erpnext/erpnext/public/js/setup_wizard.js +300,Sub Assemblies,Sub þing
DocType: Asset,Asset Name,Asset Name
DocType: Project,Task Weight,verkefni Þyngd
DocType: Shipping Rule Condition,To Value,til Value
DocType: Asset Movement,Stock Manager,Stock Manager
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +143,Source warehouse is mandatory for row {0},Source vöruhús er nauðsynlegur fyrir röð {0}
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +810,Packing Slip,pökkun Slip
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +108,Office Rent,skrifstofa leigu
apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Skipulag SMS Gateway stillingar
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +60,Import Failed!,Innflutningur mistókst!
apps/erpnext/erpnext/public/js/templates/address_list.html +21,No address added yet.,Ekkert heimilisfang bætt við enn.
DocType: Workstation Working Hour,Workstation Working Hour,Workstation vinnustund
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +87,Analyst,Analyst
DocType: Item,Inventory,Skrá
DocType: Item,Sales Details,velta Upplýsingar
DocType: Quality Inspection,QI-,QI-
DocType: Opportunity,With Items,með atriði
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,In Qty,í Magn
DocType: Notification Control,Expense Claim Rejected,Expense Krafa Hafnað
DocType: Item,Item Attribute,Liður Attribute
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +109,Government,ríkisstjórn
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Kostnað Krafa {0} er þegar til fyrir Vehicle Innskráning
apps/erpnext/erpnext/public/js/setup_wizard.js +41,Institute Name,Institute Name
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Vinsamlegast sláðu endurgreiðslu Upphæð
apps/erpnext/erpnext/config/stock.py +300,Item Variants,Item Afbrigði
DocType: Company,Services,Þjónusta
DocType: HR Settings,Email Salary Slip to Employee,Sendu Laun Slip til starfsmanns
DocType: Cost Center,Parent Cost Center,Parent Kostnaður Center
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +872,Select Possible Supplier,Veldu Möguleg Birgir
DocType: Sales Invoice,Source,Source
apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Sýna lokaðar
DocType: Leave Type,Is Leave Without Pay,Er Leyfi án launa
apps/erpnext/erpnext/stock/doctype/item/item.py +238,Asset Category is mandatory for Fixed Asset item,Asset Flokkur er nauðsynlegur fyrir Fast eignalið
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +145,No records found in the Payment table,Engar færslur finnast í Greiðsla töflunni
apps/erpnext/erpnext/schools/utils.py +19,This {0} conflicts with {1} for {2} {3},Þessi {0} átök með {1} fyrir {2} {3}
DocType: Student Attendance Tool,Students HTML,nemendur HTML
apps/erpnext/erpnext/public/js/setup_wizard.js +60,Financial Year Start Date,Fjárhagsár Start Date
DocType: POS Profile,Apply Discount,gilda Afsláttur
DocType: Employee External Work History,Total Experience,Samtals Experience
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Opið Verkefni
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +283,Packing Slip(s) cancelled,Pökkun Slip (s) Hætt
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +31,Cash Flow from Investing,Cash Flow frá Fjárfesting
DocType: Program Course,Program Course,program Námskeið
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +97,Freight and Forwarding Charges,Frakt og Áframsending Gjöld
DocType: Homepage,Company Tagline for website homepage,Fyrirtæki Yfirskrift fyrir vefsvæðið heimasíðuna
DocType: Item Group,Item Group Name,Item Group Name
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Taken
DocType: Student,Date of Leaving,Dagsetning Keyrsla
DocType: Pricing Rule,For Price List,Fyrir verðskrá
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Executive Search
apps/erpnext/erpnext/utilities/activation.py +61,Create Leads,Búa Leiða
DocType: Maintenance Schedule,Schedules,Skrár
DocType: Purchase Invoice Item,Net Amount,Virði
DocType: Purchase Order Item Supplied,BOM Detail No,BOM Detail No
DocType: Landed Cost Voucher,Additional Charges,Önnur Gjöld
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Viðbótarupplýsingar Afsláttur Magn (Company Gjaldmiðill)
apps/erpnext/erpnext/accounts/doctype/account/account.js +7,Please create new account from Chart of Accounts.,Vinsamlegast búa til nýjan reikning úr mynd af reikninga.
DocType: Maintenance Visit,Maintenance Visit,viðhald Visit
DocType: Student,Leaving Certificate Number,Lokaprófsskírteini Fjöldi
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Laus Hópur Magn á Lager
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Uppfæra Prenta Format
DocType: Landed Cost Voucher,Landed Cost Help,Landað Kostnaður Hjálp
DocType: Purchase Invoice,Select Shipping Address,Veldu Shipping Address
DocType: Leave Block List,Block Holidays on important days.,Block Holidays á mikilvægum dögum.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +71,Accounts Receivable Summary,Viðskiptakröfur Yfirlit
DocType: Employee Loan,Monthly Repayment Amount,Mánaðarlega endurgreiðslu Upphæð
apps/erpnext/erpnext/hr/doctype/employee/employee.py +191,Please set User ID field in an Employee record to set Employee Role,Vinsamlegast settu User ID reit í Starfsmannafélag met að setja Starfsmannafélag hlutverki
DocType: UOM,UOM Name,UOM Name
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,framlag Upphæð
DocType: Purchase Invoice,Shipping Address,Sendingar Address
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Þetta tól hjálpar þér að uppfæra eða festa magn og mat á lager í kerfinu. Það er oftast notuð til að samstilla kerfið gildi og hvað raunverulega er til staðar í vöruhús þínum.
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,Í orðum verður sýnileg þegar þú hefur vistað Afhending Ath.
DocType: Expense Claim,EXP,EXP
apps/erpnext/erpnext/config/stock.py +200,Brand master.,Vörumerki meistara.
apps/erpnext/erpnext/schools/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Student {0} - {1} birtist mörgum sinnum á röð {2} &amp; {3}
DocType: Program Enrollment Tool,Program Enrollments,program innritun nemenda
DocType: Sales Invoice Item,Brand Name,Vörumerki
DocType: Purchase Receipt,Transporter Details,Transporter Upplýsingar
apps/erpnext/erpnext/accounts/page/pos/pos.js +2519,Default warehouse is required for selected item,Sjálfgefið vöruhús er nauðsynlegt til valið atriði
apps/erpnext/erpnext/public/js/setup_wizard.js +303,Box,Box
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +869,Possible Supplier,Möguleg Birgir
apps/erpnext/erpnext/public/js/setup_wizard.js +36,The Organization,The Organization
DocType: Budget,Monthly Distribution,Mánaðarleg dreifing
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Receiver List er tóm. Vinsamlegast búa Receiver Listi
DocType: Production Plan Sales Order,Production Plan Sales Order,Framleiðslu Plan Velta Order
DocType: Sales Partner,Sales Partner Target,Velta Partner Target
DocType: Loan Type,Maximum Loan Amount,Hámarkslán
DocType: Pricing Rule,Pricing Rule,verðlagning Regla
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +45,Duplicate roll number for student {0},Afrita rúlla númer fyrir nemanda {0}
DocType: Budget,Action if Annual Budget Exceeded,Aðgerð ef Árleg Budget meiri en
apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Efni Beiðni um Innkaupapöntun
DocType: Shopping Cart Settings,Payment Success URL,Greiðsla Velgengni URL
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +80,Row # {0}: Returned Item {1} does not exists in {2} {3},Row # {0}: aftur hlut {1} er ekki til í {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,Reikningar
,Bank Reconciliation Statement,Bank Sættir Yfirlýsing
,Lead Name,Lead Name
,POS,POS
DocType: C-Form,III,III
apps/erpnext/erpnext/config/stock.py +305,Opening Stock Balance,Opnun Stock Balance
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} verður að birtast aðeins einu sinni
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +367,Not allowed to tranfer more {0} than {1} against Purchase Order {2},Ekki leyft að tranfer meira {0} en {1} gegn Purchase Order {2}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Leaves Úthlutað Tókst fyrir {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +40,No Items to pack,Engir hlutir í pakka
DocType: Shipping Rule Condition,From Value,frá Value
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +554,Manufacturing Quantity is mandatory,Framleiðsla Magn er nauðsynlegur
DocType: Employee Loan,Repayment Method,endurgreiðsla Aðferð
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website",Ef valið þá Heimasíða verður sjálfgefið Item Group fyrir vefsvæðið
DocType: Quality Inspection Reading,Reading 4,lestur 4
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +498,Default BOM for {0} not found for Project {1},Sjálfgefin BOM fyrir {0} ekki að finna fyrir Project {1}
apps/erpnext/erpnext/config/hr.py +127,Claims for company expense.,Kröfur fyrir VÍS.
apps/erpnext/erpnext/utilities/activation.py +116,"Students are at the heart of the system, add all your students","Nemendur eru í hjarta kerfisins, bæta við öllum nemendum"
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Row # {0}: Úthreinsun dagsetning {1} er ekki hægt áður Ávísun Dagsetning {2}
DocType: Company,Default Holiday List,Sjálfgefin Holiday List
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +187,Row {0}: From Time and To Time of {1} is overlapping with {2},Row {0}: Frá tíma og tíma af {1} er skörun við {2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Stock Liabilities,lager Skuldir
DocType: Purchase Invoice,Supplier Warehouse,birgir Warehouse
DocType: Opportunity,Contact Mobile No,Viltu samband við Mobile Nei
,Material Requests for which Supplier Quotations are not created,Efni Beiðnir sem Birgir tilvitnanir eru ekki stofnað
DocType: Student Group,Set 0 for no limit,Setja 0. engin takmörk
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.,Daginn (s) sem þú ert að sækja um leyfi eru frí. Þú þarft ekki að sækja um leyfi.
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Endursenda Greiðsla tölvupóst
apps/erpnext/erpnext/templates/pages/projects.html +27,New task,nýtt verkefni
apps/erpnext/erpnext/utilities/activation.py +72,Make Quotation,gera Tilvitnun
apps/erpnext/erpnext/config/selling.py +216,Other Reports,aðrar skýrslur
DocType: Dependent Task,Dependent Task,Dependent Task
apps/erpnext/erpnext/stock/doctype/item/item.py +407,Conversion factor for default Unit of Measure must be 1 in row {0},Breytistuðull fyrir sjálfgefið Mælieiningin skal vera 1 í röðinni {0}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +208,Leave of type {0} cannot be longer than {1},Leyfi af gerð {0} má ekki vera lengri en {1}
DocType: Manufacturing Settings,Try planning operations for X days in advance.,Prófaðu að skipuleggja starfsemi fyrir X daga fyrirvara.
DocType: HR Settings,Stop Birthday Reminders,Stop afmælisáminningar
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +255,Please set Default Payroll Payable Account in Company {0},Vinsamlegast settu Default Launaskrá Greiðist reikning í félaginu {0}
DocType: SMS Center,Receiver List,Receiver List
apps/erpnext/erpnext/accounts/page/pos/pos.js +1048,Search Item,leit Item
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,neytt Upphæð
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Net Breyting á Cash
DocType: Assessment Plan,Grading Scale,flokkun Scale
apps/erpnext/erpnext/stock/doctype/item/item.py +402,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Mælieiningin {0} hefur verið slegið oftar en einu sinni í viðskipta Factor töflu
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +600,Already completed,þegar lokið
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +28,Payment Request already exists {0},Greiðsla Beiðni þegar til staðar {0}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Kostnaður af úthlutuðum Items
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +263,Quantity must not be more than {0},Magn má ekki vera meira en {0}
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,Næstliðnu reikningsári er ekki lokað
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +44,Age (Days),Aldur (dagar)
DocType: Quotation Item,Quotation Item,Tilvitnun Item
DocType: Account,Account Name,Nafn reiknings
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,Frá Dagsetning má ekki vera meiri en hingað til
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +194,Serial No {0} quantity {1} cannot be a fraction,Serial Nei {0} magn {1} getur ekki verið brot
apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Birgir Type húsbóndi.
DocType: Purchase Order Item,Supplier Part Number,Birgir Part Number
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +100,Conversion rate cannot be 0 or 1,Viðskiptahlutfall er ekki hægt að 0 eða 1
DocType: Sales Invoice,Reference Document,Tilvísun Document
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +180,{0} {1} is cancelled or stopped,{0} {1} er aflýst eða henni hætt
DocType: Accounts Settings,Credit Controller,Credit Controller
DocType: Delivery Note,Vehicle Dispatch Date,Ökutæki Sending Dagsetning
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +229,Purchase Receipt {0} is not submitted,Kvittun {0} er ekki lögð
DocType: Company,Default Payable Account,Sjálfgefið Greiðist Reikningur
apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Stillingar fyrir online innkaupakörfu ss reglur skipum, verðlista o.fl."
apps/erpnext/erpnext/controllers/website_list_for_contact.py +86,{0}% Billed,{0}% Billed
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,frátekið Magn
DocType: Party Account,Party Account,Party Reikningur
apps/erpnext/erpnext/config/setup.py +122,Human Resources,Mannauður
DocType: Lead,Upper Income,efri Tekjur
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +13,Reject,hafna
DocType: Journal Entry Account,Debit in Company Currency,Debet í félaginu Gjaldmiðill
DocType: BOM Item,BOM Item,BOM Item
DocType: Appraisal,For Employee,fyrir starfsmann
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +41,Make Disbursement Entry,Gera útborgun færslu
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Row {0}: Advance gegn Birgir skal gjaldfæra
DocType: Company,Default Values,sjálfgefnar
DocType: Expense Claim,Total Amount Reimbursed,Heildarfjárhæð Endurgreiða
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Þetta er byggt á logs gegn þessu ökutæki. Sjá tímalínu hér fyrir nánari upplýsingar
apps/erpnext/erpnext/schools/doctype/fees/fees.js +41,Collect,safna
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +82,Against Supplier Invoice {0} dated {1},Gegn Birgir Invoice {0} dagsett {1}
DocType: Customer,Default Price List,Sjálfgefið Verðskrá
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +243,Asset Movement record {0} created,Eignastýring Hreyfing met {0} búin
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,Þú getur ekki eytt Fiscal Year {0}. Reikningsár {0} er sett sem sjálfgefið í Global Settings
DocType: Journal Entry,Entry Type,Entry Type
,Customer Credit Balance,Viðskiptavinur Credit Balance
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Change in Accounts Payable,Net Breyta í viðskiptaskuldum
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Viðskiptavinur þarf að &#39;Customerwise Afsláttur&#39;
apps/erpnext/erpnext/config/accounts.py +142,Update bank payment dates with journals.,Uppfæra banka greiðslu dagsetningar með tímaritum.
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,verðlagning
DocType: Quotation,Term Details,Term Upplýsingar
DocType: Project,Total Sales Cost (via Sales Order),Heildarkostnaður vegna sölu (með sölupöntun)
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Ekki er hægt að innritast meira en {0} nemendum fyrir þessum nemendahópi.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Leiða Count
apps/erpnext/erpnext/accounts/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} verður að vera hærri en 0
DocType: Manufacturing Settings,Capacity Planning For (Days),Getu áætlanagerð fyrir (dagar)
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Öflun
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,None of the items have any change in quantity or value.,Ekkert af þeim atriðum hafa allar breytingar á magni eða verðmæti.
apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +16,Mandatory field - Program,Lögboðið reit - Program
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +48,Warranty Claim,ábyrgð kröfu
,Lead Details,Lead Upplýsingar
DocType: Salary Slip,Loan repayment,lán endurgreiðslu
DocType: Purchase Invoice,End date of current invoice's period,Lokadagur tímabils núverandi reikningi er
DocType: Pricing Rule,Applicable For,gildir til
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Aftengja greiðsla á niðurfellingar Invoice
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Núverandi kílómetramæli lestur inn ætti að vera hærri en upphaflega Ökutæki Kílómetrastaða {0}
DocType: Shipping Rule Country,Shipping Rule Country,Sendingar Regla Country
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Leyfi og Mæting
DocType: Maintenance Visit,Partially Completed,hluta Lokið
DocType: Leave Type,Include holidays within leaves as leaves,Fela frí í laufum sem fer
DocType: Sales Invoice,Packed Items,pakkað Items
apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Ábyrgð kröfu gegn Raðnúmer
DocType: BOM Replace Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM",Skipta ákveðna BOM í öllum öðrum BOMs þar sem það er notað. Það mun koma í stað gamla BOM tengilinn uppfæra kostnað og endurnýja &quot;BOM Explosion Item&quot; borð eins og á nýju BOM
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +62,'Total',&#39;Total&#39;
DocType: Shopping Cart Settings,Enable Shopping Cart,Virkja Shopping Cart
DocType: Employee,Permanent Address,Heimilisfang
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",Fyrirframgreiðslu á móti {0} {1} getur ekki verið meiri \ en GRAND Samtals {2}
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +148,Please select item code,Vinsamlegast veldu atriði kóða
DocType: Student Sibling,Studying in Same Institute,Nám í sömu Institute
DocType: Territory,Territory Manager,Territory Manager
DocType: Packed Item,To Warehouse (Optional),Til Lager (Valfrjálst)
DocType: Payment Entry,Paid Amount (Company Currency),Greiddur Magn (Company Gjaldmiðill)
DocType: Purchase Invoice,Additional Discount,Viðbótarupplýsingar Afsláttur
DocType: Selling Settings,Selling Settings,selja Stillingar
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +39,Online Auctions,Online Uppboð
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +98,Please specify either Quantity or Valuation Rate or both,Vinsamlegast tilgreindu annaðhvort magni eða Verðmat Meta eða bæði
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +17,Fulfillment,fylling
apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Skoða í körfu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +101,Marketing Expenses,markaðskostnaður
,Item Shortage Report,Liður Skortur Report
apps/erpnext/erpnext/stock/doctype/item/item.js +257,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Þyngd er getið, \ nVinsamlega nefna &quot;Þyngd UOM&quot; of"
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Efni Beiðni notað til að gera þetta lager Entry
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Næsta Afskriftir Date er nauðsynlegur fyrir nýrri eign
DocType: Student Group Creation Tool,Separate course based Group for every Batch,Aðskilja námskeið byggt fyrir hverja lotu
apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Single eining hlut.
DocType: Fee Category,Fee Category,Fee Flokkur
,Student Fee Collection,Student Fee Collection
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Gera Bókhald færslu fyrir hvert Stock Hreyfing
DocType: Leave Allocation,Total Leaves Allocated,Samtals Leaves Úthlutað
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +155,Warehouse required at Row No {0},Warehouse þörf á Row nr {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +78,Please enter valid Financial Year Start and End Dates,Vinsamlegast sláðu inn fjárhagsári upphafs- og lokadagsetningar
DocType: Employee,Date Of Retirement,Dagsetning starfsloka
DocType: Upload Attendance,Get Template,fá sniðmát
DocType: Vehicle,Doors,hurðir
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +204,ERPNext Setup Complete!,ERPNext Uppsetningu lokið!
DocType: Course Assessment Criteria,Weightage,weightage
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}: Kostnaður Center er nauðsynlegt fyrir &#39;RekstrarliÃ&#39; reikning {2}. Vinsamlegast setja upp sjálfgefið kostnaðarstað til félagsins.
apps/erpnext/erpnext/selling/doctype/customer/customer.py +108,A Customer Group exists with same name please change the Customer name or rename the Customer Group,A Viðskiptavinur Group til staðar með sama nafni vinsamlegast breyta Customer Name eða endurnefna Viðskiptavinur Group
apps/erpnext/erpnext/public/js/templates/contact_list.html +2,New Contact,nýtt samband við
DocType: Territory,Parent Territory,Parent Territory
DocType: Quality Inspection Reading,Reading 2,lestur 2
DocType: Stock Entry,Material Receipt,efni Kvittun
DocType: Homepage,Products,Vörur
DocType: Announcement,Instructor,kennari
DocType: Employee,AB+,AB +
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Ef þessi atriði eru afbrigði, þá getur það ekki verið valinn í sölu skipunum o.fl."
DocType: Lead,Next Contact By,Næsta Samband með
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +254,Quantity required for Item {0} in row {1},Magn krafist fyrir lið {0} í röð {1}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +114,Warehouse {0} can not be deleted as quantity exists for Item {1},Warehouse {0} Ekki er hægt að eyða eins magn er fyrir hendi tl {1}
DocType: Quotation,Order Type,Order Type
DocType: Purchase Invoice,Notification Email Address,Tilkynning Netfang
,Item-wise Sales Register,Item-vitur Sales Register
DocType: Asset,Gross Purchase Amount,Gross Kaup Upphæð
DocType: Asset,Depreciation Method,Afskriftir Method
apps/erpnext/erpnext/accounts/page/pos/pos.js +688,Offline,offline
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Er þetta Tax innifalinn í grunntaxta?
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,alls Target
DocType: Program Course,Required,Áskilið
DocType: Job Applicant,Applicant for a Job,Umsækjandi um starf
DocType: Production Plan Material Request,Production Plan Material Request,Framleiðslu Plan Efni Beiðni
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +235,No Production Orders created,Engin framleiðsla Pantanir búnar
DocType: Stock Reconciliation,Reconciliation JSON,sættir JSON
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Of margir dálkar. Flytja skýrslu og prenta það með töflureikni.
DocType: Purchase Invoice Item,Batch No,hópur Nei
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Leyfa mörgum sölu skipunum gegn Purchase Order viðskiptavinar
DocType: Student Group Instructor,Student Group Instructor,Nemandi hópur kennari
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Mobile No,Guardian2 Mobile No
apps/erpnext/erpnext/setup/doctype/company/company.py +191,Main,Main
apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant,Variant
DocType: Naming Series,Set prefix for numbering series on your transactions,Setja forskeyti fyrir númerakerfi röð á viðskiptum þínum
DocType: Employee Attendance Tool,Employees HTML,starfsmenn HTML
apps/erpnext/erpnext/stock/doctype/item/item.py +421,Default BOM ({0}) must be active for this item or its template,Sjálfgefið BOM ({0}) verður að vera virkt fyrir þetta atriði eða sniðmátið sitt
DocType: Employee,Leave Encashed?,Leyfi Encashed?
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Tækifæri Frá sviði er nauðsynlegur
DocType: Email Digest,Annual Expenses,Árleg útgjöld
DocType: Item,Variants,afbrigði
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +991,Make Purchase Order,Gera Purchase Order
DocType: SMS Center,Send To,Senda til
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},Það er ekki nóg leyfi jafnvægi um leyfi Tegund {0}
DocType: Payment Reconciliation Payment,Allocated amount,úthlutað magn
DocType: Sales Team,Contribution to Net Total,Framlag til Nettó
DocType: Sales Invoice Item,Customer's Item Code,Liður viðskiptavinar Code
DocType: Stock Reconciliation,Stock Reconciliation,Stock Sættir
DocType: Territory,Territory Name,Territory Name
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +174,Work-in-Progress Warehouse is required before Submit,Work-í-gangi Warehouse er krafist áður Senda
apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Umsækjandi um starf.
DocType: Purchase Order Item,Warehouse and Reference,Warehouse og Tilvísun
DocType: Supplier,Statutory info and other general information about your Supplier,Lögbundin upplýsingar og aðrar almennar upplýsingar um birgir
DocType: Item,Serial Nos and Batches,Raðnúmer og lotur
apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Styrkur nemendahóps
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +222,Against Journal Entry {0} does not have any unmatched {1} entry,Gegn Journal Entry {0} hjartarskinn ekki hafa allir ósamþykkt {1} færslu
apps/erpnext/erpnext/config/hr.py +137,Appraisals,úttektir
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,Duplicate Serial No entered for Item {0},Afrit Serial Nei slegið í lið {0}
DocType: Shipping Rule Condition,A condition for a Shipping Rule,Skilyrði fyrir Shipping reglu
apps/erpnext/erpnext/hr/doctype/employee/employee.py +161,Please enter ,vinsamlegast sláðu
apps/erpnext/erpnext/controllers/accounts_controller.py +433,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Ekki er hægt að overbill fyrir atriðið {0} in row {1} meira en {2}. Til að leyfa yfir-innheimtu, skaltu stilla á að kaupa Stillingar"
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +188,Please set filter based on Item or Warehouse,Vinsamlegast settu síuna miðað Item eða Warehouse
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Nettóþyngd þessum pakka. (Reiknaðar sjálfkrafa sem summa nettó þyngd atriði)
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +82,Please create an Account for this Warehouse and link it. This cannot be done automatically as an account with name {0} already exists,Vinsamlegast búa til reikning fyrir þetta Lager og tengja hana. Þetta getur ekki gert sjálfkrafa eins og reikning með nafninu {0} er þegar til
DocType: Sales Order,To Deliver and Bill,Að skila og Bill
DocType: Student Group,Instructors,leiðbeinendur
DocType: GL Entry,Credit Amount in Account Currency,Credit Upphæð í Account Gjaldmiðill
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +513,BOM {0} must be submitted,BOM {0} Leggja skal fram
DocType: Authorization Control,Authorization Control,Heimildin Control
apps/erpnext/erpnext/controllers/buying_controller.py +301,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Hafnað Warehouse er nauðsynlegur móti hafnað Item {1}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +762,Payment,greiðsla
apps/erpnext/erpnext/utilities/activation.py +79,Manage your orders,Stjórna pantanir
DocType: Production Order Operation,Actual Time and Cost,Raunveruleg tíma og kostnað
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},Efni Beiðni um hámark {0} má gera ráð fyrir lið {1} gegn Velta Order {2}
DocType: Employee,Salutation,Kveðjan
DocType: Course,Course Abbreviation,Auðvitað Skammstöfun
DocType: Student Leave Application,Student Leave Application,Student Leave Umsókn
DocType: Item,Will also apply for variants,Mun einnig gilda fyrir afbrigði
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +159,"Asset cannot be cancelled, as it is already {0}","Eign er ekki hætt, eins og það er nú þegar {0}"
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Starfsmaður {0} á hálfan dag á {1}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +41,Total working hours should not be greater than max working hours {0},Samtals vinnutími ætti ekki að vera meiri en max vinnutíma {0}
apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Á
apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Knippi atriði á sölu.
DocType: Quotation Item,Actual Qty,Raunveruleg Magn
DocType: Sales Invoice Item,References,Tilvísanir
DocType: Quality Inspection Reading,Reading 10,lestur 10
apps/erpnext/erpnext/public/js/setup_wizard.js +289,"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.","Listi vörur þínar eða þjónustu sem þú kaupir eða selur. Gakktu úr skugga um að athuga Item Group, Mælieiningin og aðrar eignir þegar þú byrjar."
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.,Þú hefur slegið afrit atriði. Vinsamlegast lagfæra og reyndu aftur.
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +91,Associate,Félagi
DocType: Asset Movement,Asset Movement,Asset Hreyfing
apps/erpnext/erpnext/accounts/page/pos/pos.js +2066,New Cart,nýtt körfu
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Liður {0} er ekki serialized Item
DocType: SMS Center,Create Receiver List,Búa Receiver lista
DocType: Vehicle,Wheels,hjól
DocType: Packing Slip,To Package No.,Til spakki
DocType: Production Planning Tool,Material Requests,efni Beiðnir
DocType: Warranty Claim,Issue Date,Útgáfudagur
DocType: Activity Cost,Activity Cost,virkni Kostnaður
DocType: Sales Invoice Timesheet,Timesheet Detail,timesheet Detail
DocType: Purchase Receipt Item Supplied,Consumed Qty,neytt Magn
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +52,Telecommunications,Fjarskipti
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Gefur til kynna að pakki er hluti af þessari fæðingu (Only Draft)
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Greiða færslu
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +126,Quantity for Item {0} must be less than {1},Magn í lið {0} verður að vera minna en {1}
,Sales Invoice Trends,Sölureikningi Trends
DocType: Leave Application,Apply / Approve Leaves,Beita / Samþykkja Leaves
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +23,For,fyrir
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +142,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Getur átt röð ef gjaldið er af gerðinni &#39;On Fyrri Row Upphæð&#39; eða &#39;Fyrri Row Total&#39;
DocType: Sales Order Item,Delivery Warehouse,Afhending Warehouse
DocType: SMS Settings,Message Parameter,Message Parameter
apps/erpnext/erpnext/config/accounts.py +210,Tree of financial Cost Centers.,Tré fjárhagslegum stoðsviða.
DocType: Serial No,Delivery Document No,Afhending Skjal nr
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +184,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Vinsamlegast settu &quot;hagnaður / tap reikning á Asset förgun&quot; í félaginu {0}
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Fá atriði úr Purchase Kvittanir
DocType: Serial No,Creation Date,Creation Date
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},Liður {0} birtist mörgum sinnum á verðskrá {1}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +40,"Selling must be checked, if Applicable For is selected as {0}","Selja verður að vera merkt, ef við á er valið sem {0}"
DocType: Production Plan Material Request,Material Request Date,Efni Beiðni Dagsetning
DocType: Purchase Order Item,Supplier Quotation Item,Birgir Tilvitnun Item
DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Slekkur sköpun tíma logs gegn Production Orders. Reksturinn skal ekki raktar gegn Production Order
DocType: Student,Student Mobile Number,Student Mobile Number
DocType: Item,Has Variants,hefur Afbrigði
apps/erpnext/erpnext/public/js/utils.js +176,You have already selected items from {0} {1},Þú hefur nú þegar valið hluti úr {0} {1}
DocType: Monthly Distribution,Name of the Monthly Distribution,Heiti Monthly Distribution
apps/erpnext/erpnext/stock/doctype/batch/batch.py +25,Batch ID is mandatory,Hópur auðkenni er nauðsynlegur
DocType: Sales Person,Parent Sales Person,Móðurfélag Sales Person
DocType: Purchase Invoice,Recurring Invoice,Fastir Invoice
apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Annast verkefni
DocType: Supplier,Supplier of Goods or Services.,Seljandi vöru eða þjónustu.
DocType: Budget,Fiscal Year,Fiscal Year
DocType: Vehicle Log,Fuel Price,eldsneyti verð
DocType: Budget,Budget,Budget
apps/erpnext/erpnext/stock/doctype/item/item.py +235,Fixed Asset Item must be a non-stock item.,Fast Asset Item verður a non-birgðir atriði.
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Fjárhagsáætlun er ekki hægt að úthlutað gegn {0}, eins og það er ekki tekjur eða gjöld reikning"
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,náð
DocType: Student Admission,Application Form Route,Umsóknareyðublað Route
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +67,Territory / Customer,Territory / Viðskiptavinur
apps/erpnext/erpnext/public/js/setup_wizard.js +232,e.g. 5,td 5
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,Skildu Type {0} er ekki hægt að úthluta þar sem það er leyfi án launa
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}: Reiknaðar upphæð {1} verður að vera minna en eða jafnt og til reikning útistandandi upphæð {2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,Í orðum verður sýnileg þegar þú vistar sölureikningi.
DocType: Item,Is Sales Item,Er Sales Item
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Liður Group Tree
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,Liður {0} er ekki skipulag fyrir Serial Nos. Athuga Item meistara
DocType: Maintenance Visit,Maintenance Time,viðhald Time
,Amount to Deliver,Nema Bera
apps/erpnext/erpnext/public/js/setup_wizard.js +297,A Product or Service,Vörur eða þjónusta
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.,Hugtakið Start Date getur ekki verið fyrr en árið upphafsdagur skólaárið sem hugtakið er tengt (skólaárið {}). Vinsamlega leiðréttu dagsetningar og reyndu aftur.
DocType: Guardian,Guardian Interests,Guardian Áhugasvið
DocType: Naming Series,Current Value,Núverandi Value
apps/erpnext/erpnext/controllers/accounts_controller.py +252,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Margar reikningsárin til fyrir dagsetningu {0}. Vinsamlegast settu fyrirtæki í Fiscal Year
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +233,{0} created,{0} búin
DocType: Delivery Note Item,Against Sales Order,Against Sales Order
,Serial No Status,Serial Nei Staða
DocType: Payment Entry Reference,Outstanding,Framúrskarandi
,Daily Timesheet Summary,Daily Timesheet Yfirlit
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +138,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Row {0}: Til að stilla {1} tíðni, munurinn frá og til dagsetning \ verður að vera meiri en eða jafnt og {2}"
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Þetta er byggt á lager hreyfingu. Sjá {0} for details
DocType: Pricing Rule,Selling,selja
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +351,Amount {0} {1} deducted against {2},Upphæð {0} {1} frádráttar {2}
DocType: Employee,Salary Information,laun Upplýsingar
DocType: Sales Person,Name and Employee ID,Nafn og Starfsmannafélag ID
apps/erpnext/erpnext/accounts/party.py +289,Due Date cannot be before Posting Date,Skiladagur er ekki hægt áður Staða Dagsetning
DocType: Website Item Group,Website Item Group,Vefsíða Item Group
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +148,Duties and Taxes,Skyldur og skattar
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,Vinsamlegast sláðu viðmiðunardagur
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} greiðsla færslur er ekki hægt að sía eftir {1}
DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tafla fyrir lið sem verður sýnd í Web Site
DocType: Purchase Order Item Supplied,Supplied Qty,Staðar Magn
DocType: Purchase Order Item,Material Request Item,Efni Beiðni Item
apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Tré Item hópa.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +152,Cannot refer row number greater than or equal to current row number for this Charge type,Getur ekki átt línunúmeri meiri en eða jafnt og núverandi röð númer fyrir þessa Charge tegund
DocType: Asset,Sold,selt
,Item-wise Purchase History,Item-vitur Purchase History
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +231,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Vinsamlegast smelltu á &#39;Búa Stundaskrá&#39; að ná Serial Nei bætt við fyrir lið {0}
DocType: Account,Frozen,Frozen
,Open Production Orders,Opið Framleiðslu Pantanir
DocType: Sales Invoice Payment,Base Amount (Company Currency),Base Magn (Company Gjaldmiðill)
DocType: Payment Reconciliation Payment,Reference Row,Tilvísun Row
DocType: Installation Note,Installation Time,uppsetning Time
DocType: Sales Invoice,Accounting Details,Bókhalds Upplýsingar
apps/erpnext/erpnext/setup/doctype/company/company.js +70,Delete all the Transactions for this Company,Eyða öllum viðskiptum fyrir þetta fyrirtæki
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +189,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} er ekki lokið fyrir {2} Fjöldi fullunnum vörum í framleiðslu Order # {3}. Uppfærðu rekstur stöðu með Time Logs
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +66,Investments,Fjárfestingar
DocType: Issue,Resolution Details,upplausn Upplýsingar
apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,úthlutanir
DocType: Item Quality Inspection Parameter,Acceptance Criteria,samþykktarviðmiðanir
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +163,Please enter Material Requests in the above table,Vinsamlegast sláðu Efni Beiðnir í töflunni hér að ofan
DocType: Item Attribute,Attribute Name,eigindi nafn
DocType: BOM,Show In Website,Sýna í Vefsíða
DocType: Shopping Cart Settings,Show Quantity in Website,Sýna Magn í vefsvæðis
DocType: Employee Loan Application,Total Payable Amount,Alls Greiðist Upphæð
DocType: Task,Expected Time (in hours),Væntanlegur Time (í klst)
DocType: Item Reorder,Check in (group),Innritun (hópur)
,Qty to Order,Magn til að panta
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Reikningurinn höfuð undir ábyrgð eða Equity, sem Hagnaður / Tap verður færður"
apps/erpnext/erpnext/config/projects.py +25,Gantt chart of all tasks.,Gantt graf af öllum verkefnum.
DocType: Opportunity,Mins to First Response,Mins to First Response
DocType: Pricing Rule,Margin Type,spássía Type
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} klukkustundir
DocType: Course,Default Grading Scale,Sjálfgefið flokkun Scale
DocType: Appraisal,For Employee Name,Fyrir Starfsmannafélag Nafn
DocType: Holiday List,Clear Table,Hreinsa Tafla
DocType: C-Form Invoice Detail,Invoice No,reikningur nr
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +342,Make Payment,Greiða
DocType: Room,Room Name,Room Name
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}","Skildu ekki hægt að beita / aflýst áður {0}, sem orlof jafnvægi hefur þegar verið fært sendar í framtíðinni leyfi úthlutun met {1}"
DocType: Activity Cost,Costing Rate,kosta Rate
,Customer Addresses And Contacts,Viðskiptavinur heimilisföngum og Tengiliðir
,Campaign Efficiency,Virkni herferðar
DocType: Discussion,Discussion,umræða
DocType: Payment Entry,Transaction ID,Færsla ID
DocType: Employee,Resignation Letter Date,Störfum Letter Dagsetning
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +37,Pricing Rules are further filtered based on quantity.,Verðlagning Reglurnar eru frekar síuð miðað við magn.
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +330,Please set the Date Of Joining for employee {0},Vinsamlegast settu Dagsetning Tengingar fyrir starfsmann {0}
DocType: Task,Total Billing Amount (via Time Sheet),Total Billing Magn (með Time Sheet)
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Endurtaka Tekjur viðskiptavinar
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +164,{0} ({1}) must have role 'Expense Approver',{0} ({1}) verða að hafa hlutverk &#39;kostnað samþykkjari&#39;
apps/erpnext/erpnext/public/js/setup_wizard.js +303,Pair,pair
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +884,Select BOM and Qty for Production,Veldu BOM og Magn fyrir framleiðslu
DocType: Asset,Depreciation Schedule,Afskriftir Stundaskrá
DocType: Bank Reconciliation Detail,Against Account,Against reikninginn
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 ætti að vera á milli Frá Dagsetning og hingað
DocType: Maintenance Schedule Detail,Actual Date,Raunveruleg Dagsetning
DocType: Item,Has Batch No,Hefur Batch No
apps/erpnext/erpnext/public/js/utils.js +90,Annual Billing: {0},Árleg Billing: {0}
DocType: Delivery Note,Excise Page Number,Vörugjöld Page Number
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +138,"Company, From Date and To Date is mandatory","Company, Frá Dagsetning og hingað til er nauðsynlegur"
DocType: Asset,Purchase Date,kaupdegi
DocType: Employee,Personal Details,Persónulegar upplýsingar
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +186,Please set 'Asset Depreciation Cost Center' in Company {0},Vinsamlegast settu &quot;Asset Afskriftir Kostnaður Center&quot; í félaginu {0}
,Maintenance Schedules,viðhald Skrár
DocType: Task,Actual End Date (via Time Sheet),Raunveruleg End Date (með Time Sheet)
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +346,Amount {0} {1} against {2} {3},Upphæð {0} {1} gegn {2} {3}
,Quotation Trends,Tilvitnun Trends
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +159,Item Group not mentioned in item master for item {0},Item Group ekki getið í master lið fyrir lið {0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +339,Debit To account must be a Receivable account,Debit Til reikning verður að vera Krafa reikning
DocType: Shipping Rule Condition,Shipping Amount,Sendingar Upphæð
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Bíður Upphæð
DocType: Purchase Invoice Item,Conversion Factor,ummyndun Factor
DocType: Purchase Order,Delivered,afhent
,Vehicle Expenses,ökutæki Útgjöld
DocType: Serial No,Invoice Details,Reikningsupplýsingar
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +154,Expected value after useful life must be greater than or equal to {0},Væntanlegur gildi eftir nýtingartíma skal vera meiri en eða jafnt og {0}
DocType: Purchase Receipt,Vehicle Number,ökutæki Number
DocType: Purchase Invoice,The date on which recurring invoice will be stop,Dagsetningin sem endurteknar reikningur verður að hætta
DocType: Employee Loan,Loan Amount,lánsfjárhæð
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +391,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Efnislisti finnst ekki fyrir þar sem efnið {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,Samtals úthlutað leyfi {0} má ekki vera minna en þegar hafa verið samþykktar lauf {1} fyrir tímabilið
DocType: Journal Entry,Accounts Receivable,Reikningur fáanlegur
,Supplier-Wise Sales Analytics,Birgir-Wise Sales Analytics
apps/erpnext/erpnext/schools/doctype/fees/fees.js +41,Enter Paid Amount,Sláðu greitt upphæð
DocType: Salary Structure,Select employees for current Salary Structure,Valið starfsmenn líðandi laun uppbyggingu
DocType: Production Order,Use Multi-Level BOM,Notaðu Multi-Level BOM
DocType: Bank Reconciliation,Include Reconciled Entries,Fela sáttir færslur
DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Foreldraforrit (Leyfi blank, ef þetta er ekki hluti af foreldradeild)"
DocType: Leave Control Panel,Leave blank if considered for all employee types,Skildu eftir autt ef það er talið fyrir allar gerðir starfsmanna
DocType: Landed Cost Voucher,Distribute Charges Based On,Dreifa Gjöld Byggt á
apps/erpnext/erpnext/templates/pages/projects.html +48,Timesheets,timesheets
DocType: HR Settings,HR Settings,HR Stillingar
DocType: Salary Slip,net pay info,nettó borga upplýsingar
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +123,Expense Claim is pending approval. Only the Expense Approver can update status.,Kostnað Krafa bíður samþykkis. Aðeins kostnað samþykki getur uppfært stöðuna.
DocType: Email Digest,New Expenses,ný Útgjöld
DocType: Purchase Invoice,Additional Discount Amount,Viðbótarupplýsingar Afsláttur Upphæð
apps/erpnext/erpnext/controllers/accounts_controller.py +541,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Row # {0}: Magn verður að vera 1, eins atriði er fastur eign. Notaðu sérstaka röð fyrir margar Magn."
DocType: Leave Block List Allow,Leave Block List Allow,Skildu Block List Leyfa
apps/erpnext/erpnext/setup/doctype/company/company.py +276,Abbr can not be blank or space,Skammstöfun má ekki vera autt eða bil
apps/erpnext/erpnext/accounts/doctype/account/account.js +53,Group to Non-Group,Group Non-Group
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,Íþróttir
DocType: Loan Type,Loan Name,lán Name
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,alls Raunveruleg
DocType: Student Siblings,Student Siblings,Student Systkini
apps/erpnext/erpnext/public/js/setup_wizard.js +303,Unit,Unit
apps/erpnext/erpnext/stock/get_item_details.py +131,Please specify Company,Vinsamlegast tilgreinið Company
,Customer Acquisition and Loyalty,Viðskiptavinur Kaup og Hollusta
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,Warehouse þar sem þú ert að halda úttekt hafnað atriðum
DocType: Production Order,Skip Material Transfer,Hoppa yfir efni
apps/erpnext/erpnext/setup/utils.py +96,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Ekki er hægt að finna gengi fyrir {0} til {1} fyrir lykilatriði {2}. Vinsamlegast búðu til gjaldeyrisviðskipti handvirkt
apps/erpnext/erpnext/public/js/setup_wizard.js +63,Your financial year ends on,Fjárhagsár lýkur á
DocType: POS Profile,Price List,Verðskrá
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} er nú sjálfgefið Fiscal Year. Vinsamlegast hressa vafrann til að breytingin taki gildi.
apps/erpnext/erpnext/projects/doctype/task/task.js +37,Expense Claims,kostnaðarliðir Kröfur
DocType: Issue,Support,Stuðningur
,BOM Search,BOM leit
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +189,Closing (Opening + Totals),Lokun (Opnun Samtölur +)
DocType: Vehicle,Fuel Type,eldsneytistegund
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Vinsamlegast tilgreinið gjaldmiðil í félaginu
DocType: Workstation,Wages per hour,Laun á klukkustund
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},Stock jafnvægi í Batch {0} verður neikvætt {1} fyrir lið {2} í Warehouse {3}
apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Eftirfarandi efni beiðnir hafa verið hækkaðir sjálfvirkt miðað aftur röð stigi atriðisins
DocType: Email Digest,Pending Sales Orders,Bíður sölu skipunum
apps/erpnext/erpnext/controllers/accounts_controller.py +289,Account {0} is invalid. Account Currency must be {1},Reikningur {0} er ógild. Reikningur Gjaldmiðill verður að vera {1}
apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},UOM viðskipta þáttur er krafist í röð {0}
DocType: Production Plan Item,material_request_item,material_request_item
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +978,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Row # {0}: Tilvísun Document Type verður að vera einn af Sales Order, Sales Invoice eða Journal Entry"
DocType: Salary Component,Deduction,frádráttur
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +112,Row {0}: From Time and To Time is mandatory.,Row {0}: Frá Time og til tími er nauðsynlegur.
DocType: Stock Reconciliation Item,Amount Difference,upphæð Mismunur
apps/erpnext/erpnext/stock/get_item_details.py +286,Item Price added for {0} in Price List {1},Atriði Verð bætt fyrir {0} í verðskrá {1}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Vinsamlegast sláðu Starfsmaður Id þessarar velta manneskja
DocType: Territory,Classification of Customers by region,Flokkun viðskiptavina eftir svæðum
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +55,Difference Amount must be zero,Munurinn Upphæð verður að vera núll
DocType: Project,Gross Margin,Heildarframlegð
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +201,Please enter Production Item first,Vinsamlegast sláðu Production Item fyrst
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Útreiknuð Bank Yfirlýsing jafnvægi
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,fatlaður notandi
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +744,Quotation,Tilvitnun
DocType: Quotation,QTN-,QTN-
DocType: Salary Slip,Total Deduction,Samtals Frádráttur
,Production Analytics,framleiðslu Analytics
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +172,Cost Updated,kostnaður Uppfært
DocType: Employee,Date of Birth,Fæðingardagur
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +128,Item {0} has already been returned,Liður {0} hefur þegar verið skilað
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,** Fiscal Year ** táknar fjárhagsári. Öll bókhald færslur og aðrar helstu viðskipti eru raktar gegn ** Fiscal Year **.
DocType: Opportunity,Customer / Lead Address,Viðskiptavinur / Lead Address
apps/erpnext/erpnext/stock/doctype/item/item.py +210,Warning: Invalid SSL certificate on attachment {0},Viðvörun: Ógild SSL vottorð á viðhengi {0}
DocType: Student Admission,Eligibility,hæfi
apps/erpnext/erpnext/utilities/activation.py +62,"Leads help you get business, add all your contacts and more as your leads","Leiðir hjálpa þér að fá fyrirtæki, bæta alla tengiliði þína og fleiri sem leiðir þínar"
DocType: Production Order Operation,Actual Operation Time,Raunveruleg Operation Time
DocType: Authorization Rule,Applicable To (User),Gildir til (User)
DocType: Purchase Taxes and Charges,Deduct,draga
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +188,Job Description,Starfslýsing
DocType: Student Applicant,Applied,Applied
DocType: Sales Invoice Item,Qty as per Stock UOM,Magn eins og á lager UOM
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian2 Name,Guardian2 Name
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +131,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Sérstafir nema &quot;-&quot; &quot;.&quot;, &quot;#&quot;, og &quot;/&quot; ekki leyfð í nafngiftir röð"
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Halda utan um sölu herferðir. Haldið utan um leiðir, tilvitnanir, Sales Order etc frá herferðir til að meta arðsemi fjárfestingarinnar."
DocType: Expense Claim,Approver,samþykkjari
,SO Qty,SO Magn
DocType: Guardian,Work Address,vinna Address
DocType: Appraisal,Calculate Total Score,Reikna aðaleinkunn
DocType: Request for Quotation,Manufacturing Manager,framleiðsla Manager
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +192,Serial No {0} is under warranty upto {1},Serial Nei {0} er undir ábyrgð uppí {1}
apps/erpnext/erpnext/config/stock.py +158,Split Delivery Note into packages.,Split Afhending Note í pakka.
apps/erpnext/erpnext/hooks.py +87,Shipments,sendingar
apps/erpnext/erpnext/accounts/doctype/account/account.py +191,Account balance ({0}) for {1} and stock value ({2}) for warehouse {3} must be same,Reikningsjafnvægi ({0}) fyrir {1} og verðmæti lager ({2}) fyrir vöruhús {3} verður að vera sama
DocType: Payment Entry,Total Allocated Amount (Company Currency),Total úthlutað magn (Company Gjaldmiðill)
DocType: Purchase Order Item,To be delivered to customer,Til að vera frelsari til viðskiptavina
DocType: BOM,Scrap Material Cost,Rusl efniskostnaði
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +223,Serial No {0} does not belong to any Warehouse,Serial Nei {0} er ekki tilheyra neinum Warehouse
DocType: Purchase Invoice,In Words (Company Currency),Í orðum (Company Gjaldmiðill)
DocType: Asset,Supplier,birgir
DocType: C-Form,Quarter,Quarter
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +104,Miscellaneous Expenses,Ýmis Útgjöld
DocType: Global Defaults,Default Company,Sjálfgefið Company
apps/erpnext/erpnext/controllers/stock_controller.py +229,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Kostnað eða Mismunur reikningur er nauðsynlegur fyrir lið {0} eins og það hefur áhrif á heildina birgðir gildi
DocType: Payment Request,PR,PR
DocType: Cheque Print Template,Bank Name,Nafn banka
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +27,-Above,-Above
DocType: Employee Loan,Employee Loan Account,Starfsmaður Lán Reikningur
DocType: Leave Application,Total Leave Days,Samtals leyfisdaga
DocType: Email Digest,Note: Email will not be sent to disabled users,Ath: Email verður ekki send til fatlaðra notenda
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Fjöldi samskipta
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +41,Select Company...,Veldu Company ...
DocType: Leave Control Panel,Leave blank if considered for all departments,Skildu eftir autt ef það er talið að öllum deildum
apps/erpnext/erpnext/config/hr.py +219,"Types of employment (permanent, contract, intern etc.).","Tegundir ráðninga (varanleg, samningur, nemi o.fl.)."
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +405,{0} is mandatory for Item {1},{0} er nauðsynlegur fyrir lið {1}
DocType: Process Payroll,Fortnightly,hálfsmánaðarlega
DocType: Currency Exchange,From Currency,frá Gjaldmiðill
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +170,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Vinsamlegast veldu úthlutað magn, tegundir innheimtuseðla og reikningsnúmerið í atleast einni röð"
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +125,Cost of New Purchase,Kostnaður við nýja kaup
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +94,Sales Order required for Item {0},Velta Order krafist fyrir lið {0}
DocType: Purchase Invoice Item,Rate (Company Currency),Hlutfall (Company Gjaldmiðill)
DocType: Student Guardian,Others,aðrir
DocType: Payment Entry,Unallocated Amount,óráðstafað Upphæð
apps/erpnext/erpnext/templates/includes/product_page.js +69,Cannot find a matching Item. Please select some other value for {0}.,Get ekki fundið samsvörun hlut. Vinsamlegast veldu einhverja aðra verðmæti fyrir {0}.
DocType: POS Profile,Taxes and Charges,Skattar og gjöld
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","A vöru eða þjónustu sem er keypt, selt eða haldið á lager."
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Ekki fleiri uppfærslur
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +146,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Get ekki valið gjald tegund sem &quot;On Fyrri Row Upphæð &#39;eða&#39; Á fyrri röðinni Samtals &#39;fyrir fyrstu röðinni
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,Barnið Item ætti ekki að vera Product Knippi. Fjarlægðu hlut `{0}` og vista
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Banking
apps/erpnext/erpnext/utilities/activation.py +106,Add Timesheets,bæta við timesheets
DocType: Vehicle Service,Service Item,þjónusta Item
DocType: Bank Guarantee,Bank Guarantee,Bankábyrgð
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Vinsamlegast smelltu á &#39;Búa Stundaskrá&#39; til að fá áætlun
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +56,There were errors while deleting following schedules:,Það komu upp villur við eytt eftirfarandi tímaáætlun:
DocType: Bin,Ordered Quantity,Raðaður Magn
apps/erpnext/erpnext/public/js/setup_wizard.js +52,"e.g. ""Build tools for builders""",td &quot;Byggja verkfæri fyrir smiðirnir&quot;
DocType: Grading Scale,Grading Scale Intervals,Flokkun deilingargildi
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}: Bókhald Entry fyrir {2} Aðeins er hægt að gera í gjaldmiðli: {3}
DocType: Production Order,In Process,Í ferli
DocType: Authorization Rule,Itemwise Discount,Itemwise Afsláttur
apps/erpnext/erpnext/config/accounts.py +69,Tree of financial accounts.,Tré ársreikning.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} gegn Velta Order {1}
DocType: Account,Fixed Asset,fast Asset
apps/erpnext/erpnext/config/stock.py +315,Serialized Inventory,serialized Inventory
DocType: Employee Loan,Account Info,Reikningur Upplýsingar
DocType: Activity Type,Default Billing Rate,Sjálfgefið Billing Rate
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +71,{0} Student Groups created.,{0} Nemendahópar búin til.
DocType: Sales Invoice,Total Billing Amount,Alls innheimtu upphæð
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.,Það verður að vera sjálfgefið komandi Email Account virkt til að þetta virki. Vinsamlegast skipulag sjálfgefið komandi netfangs (POP / IMAP) og reyndu aftur.
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +59,Receivable Account,viðskiptakröfur Reikningur
apps/erpnext/erpnext/controllers/accounts_controller.py +563,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} er þegar {2}
DocType: Quotation Item,Stock Balance,Stock Balance
apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Velta Order til greiðslu
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +85,CEO,forstjóri
DocType: Expense Claim Detail,Expense Claim Detail,Expense Krafa Detail
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +860,Please select correct account,Vinsamlegast veldu réttan reikning
DocType: Item,Weight UOM,þyngd UOM
DocType: Salary Structure Employee,Salary Structure Employee,Laun Uppbygging Starfsmaður
DocType: Employee,Blood Group,Blóðflokkur
DocType: Production Order Operation,Pending,Bíður
DocType: Course,Course Name,Auðvitað Name
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Notendur sem getur samþykkt yfirgefa forrit tiltekins starfsmanns
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +50,Office Equipments,Skrifstofa útbúnaður
DocType: Purchase Invoice Item,Qty,Magn
DocType: Fiscal Year,Companies,Stofnanir
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +24,Electronics,Electronics
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Hækka Material Beiðni þegar birgðir nær aftur röð stigi
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +60,Full-time,Fullt
DocType: Salary Structure,Employees,starfsmenn
DocType: Employee,Contact Details,Tengiliðaupplýsingar
DocType: C-Form,Received Date,fékk Date
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Ef þú hefur búið til staðlaða sniðmát í sölu sköttum og gjöldum Snið, veldu einn og smelltu á hnappinn hér fyrir neðan."
DocType: BOM Scrap Item,Basic Amount (Company Currency),Basic Magn (Company Gjaldmiðill)
DocType: Student,Guardians,forráðamenn
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Verð verður ekki sýnd ef verðskrá er ekki sett
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +28,Please specify a country for this Shipping Rule or check Worldwide Shipping,Vinsamlegast tilgreindu land fyrir þessa Shipping reglu eða stöðva Worldwide Shipping
DocType: Stock Entry,Total Incoming Value,Alls Komandi Value
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +333,Debit To is required,Skuldfærslu Til er krafist
apps/erpnext/erpnext/utilities/activation.py +107,"Timesheets help keep track of time, cost and billing for activites done by your team","Timesheets að halda utan um tíma, kostnað og innheimtu fyrir athafnir gert með lið"
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Kaupverðið List
DocType: Offer Letter Term,Offer Term,Tilboð Term
DocType: Quality Inspection,Quality Manager,gæðastjóri
DocType: Job Applicant,Job Opening,Atvinna Opnun
DocType: Payment Reconciliation,Payment Reconciliation,greiðsla Sættir
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +154,Please select Incharge Person's name,Vinsamlegast veldu nafn incharge einstaklingsins
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +51,Technology,tækni
apps/erpnext/erpnext/public/js/utils.js +92,Total Unpaid: {0},Samtals Ógreitt: {0}
DocType: BOM Website Operation,BOM Website Operation,BOM Website Operation
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Tilboðsbréf
apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Búa Efni Beiðnir (MRP) og framleiðsla pantanir.
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68,Total Invoiced Amt,Alls reikningsfærð Amt
DocType: BOM,Conversion Rate,Viðskiptahlutfallsbil
apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Vöruleit
DocType: Timesheet Detail,To Time,til Time
DocType: Authorization Rule,Approving Role (above authorized value),Samþykkir hlutverk (að ofan er leyft gildi)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +110,Credit To account must be a Payable account,Inneign á reikninginn verður að vera Greiðist reikning
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +272,BOM recursion: {0} cannot be parent or child of {2},BOM endurkvæmni: {0} er ekki hægt að foreldri eða barn {2}
DocType: Production Order Operation,Completed Qty,lokið Magn
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry","Fyrir {0}, aðeins debetkort reikninga er hægt að tengja við aðra tekjufærslu"
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Verðlisti {0} er óvirk
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty cannot be more than {1} for operation {2},Row {0}: Lokið Magn má ekki vera meira en {1} fyrir aðgerð {2}
DocType: Manufacturing Settings,Allow Overtime,leyfa yfirvinnu
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +146,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","Serialized Item {0} er ekki hægt að uppfæra með Stock Sátt, vinsamlegast notaðu Stock Entry"
DocType: Training Event Employee,Training Event Employee,Þjálfun Event Starfsmaður
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +197,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Serial Numbers krafist fyrir lið {1}. Þú hefur veitt {2}.
DocType: Stock Reconciliation Item,Current Valuation Rate,Núverandi Verðmat Rate
DocType: Item,Customer Item Codes,Viðskiptavinur Item Codes
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Exchange Gain/Loss,Gengishagnaður / tap
DocType: Opportunity,Lost Reason,Lost Ástæða
apps/erpnext/erpnext/public/js/templates/address_list.html +1,New Address,ný Address
DocType: Quality Inspection,Sample Size,Prufustærð
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +45,Please enter Receipt Document,Vinsamlegast sláðu inn Kvittun Skjal
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +373,All items have already been invoiced,Allir hlutir hafa nú þegar verið færðar á vörureikning
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +47,Please specify a valid 'From Case No.',Vinsamlegast tilgreinið gilt &quot;Frá máli nr &#39;
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,Frekari stoðsviða er hægt að gera undir Hópar en færslur er hægt að gera á móti non-hópa
DocType: Project,External,ytri
apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Notendur og heimildir
DocType: Vehicle Log,VLOG.,Vlog.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +917,Production Orders Created: {0},Framleiðslu Pantanir Búið til: {0}
DocType: Branch,Branch,Branch
DocType: Guardian,Mobile Number,Farsímanúmer
apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Prentun og merkingu
DocType: Bin,Actual Quantity,Raunveruleg Magn
DocType: Shipping Rule,example: Next Day Shipping,dæmi: Næsti dagur Shipping
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +188,Serial No {0} not found,Serial Nei {0} fannst ekki
DocType: Scheduling Tool,Student Batch,Student Hópur
apps/erpnext/erpnext/public/js/setup_wizard.js +242,Your Customers,Viðskiptavinir þínir
apps/erpnext/erpnext/utilities/activation.py +117,Make Student,gera Student
apps/erpnext/erpnext/projects/doctype/project/project.py +190,You have been invited to collaborate on the project: {0},Þér hefur verið boðið að vinna að verkefninu: {0}
DocType: Leave Block List Date,Block Date,Block Dagsetning
apps/erpnext/erpnext/templates/generators/student_admission.html +23,Apply Now,Sæktu um núna
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Raunverulegur fjöldi {0} / biðþáttur {1}
DocType: Sales Order,Not Delivered,ekki Skilað
,Bank Clearance Summary,Bank Úthreinsun Yfirlit
apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Búa til og stjórna daglega, vikulega og mánaðarlega email meltir."
DocType: Appraisal Goal,Appraisal Goal,Úttekt Goal
DocType: Stock Reconciliation Item,Current Amount,Núverandi Upphæð
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +56,Buildings,Byggingar
DocType: Fee Structure,Fee Structure,Gjald Uppbygging
DocType: Timesheet Detail,Costing Amount,kosta Upphæð
DocType: Student Admission,Application Fee,Umsókn Fee
DocType: Process Payroll,Submit Salary Slip,Senda Laun Slip
apps/erpnext/erpnext/controllers/selling_controller.py +162,Maxiumm discount for Item {0} is {1}%,Maxiumm afsláttur fyrir Liður {0} er {1}%
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Innflutningur á lausu
DocType: Sales Partner,Address & Contacts,Heimilisfang og Tengiliðir
DocType: SMS Log,Sender Name,Sendandi Nafn
DocType: POS Profile,[Select],[Veldu]
DocType: SMS Log,Sent To,send til
DocType: Payment Request,Make Sales Invoice,Gera sölureikning
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +59,Softwares,hugbúnaður
apps/erpnext/erpnext/crm/doctype/lead/lead.py +50,Next Contact Date cannot be in the past,Næsta Hafa Date getur ekki verið í fortíðinni
DocType: Company,For Reference Only.,Til viðmiðunar aðeins.
apps/erpnext/erpnext/accounts/page/pos/pos.js +2400,Select Batch No,Veldu lotu nr
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},Ógild {0}: {1}
DocType: Purchase Invoice,PINV-RET-,PINV-RET-
DocType: Sales Invoice Advance,Advance Amount,Advance Magn
DocType: Manufacturing Settings,Capacity Planning,getu Planning
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,&quot;Frá Dagsetning &#39;er krafist
DocType: Journal Entry,Reference Number,Tilvísunarnúmer
DocType: Employee,Employment Details,Nánar Atvinna
DocType: Employee,New Workplace,ný Vinnustaðurinn
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Setja sem Lokað
apps/erpnext/erpnext/stock/get_item_details.py +121,No Item with Barcode {0},Ekkert atriði með Strikamerki {0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Case Nei getur ekki verið 0
DocType: Item,Show a slideshow at the top of the page,Sýnið skyggnusýningu efst á síðunni
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +447,Boms,Boms
apps/erpnext/erpnext/stock/doctype/item/item.py +135,Stores,verslanir
DocType: Serial No,Delivery Time,Afhendingartími
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Öldrun Byggt á
DocType: Item,End of Life,End of Life
apps/erpnext/erpnext/demo/setup/setup_data.py +325,Travel,ferðalög
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,No active or default Salary Structure found for employee {0} for the given dates,Engin virk eða vanræksla Laun Uppbygging finna fyrir starfsmann {0} fyrir gefnar dagsetningar
DocType: Leave Block List,Allow Users,leyfa notendum
DocType: Purchase Order,Customer Mobile No,Viðskiptavinur Mobile Nei
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Track sérstakt Vaxtatekjur og vaxtagjöld fyrir Þrep vöru eða deildum.
DocType: Rename Tool,Rename Tool,endurnefna Tól
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +25,Update Cost,Uppfæra Kostnaður
DocType: Item Reorder,Item Reorder,Liður Uppröðun
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +437,Show Salary Slip,Sýna Laun Slip
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +786,Transfer Material,Transfer Efni
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Tilgreina rekstur, rekstrarkostnaði og gefa einstakt notkun eigi að rekstri þínum."
apps/erpnext/erpnext/controllers/status_updater.py +190,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Þetta skjal er yfir mörkum með {0} {1} fyrir lið {4}. Ert þú að gera annað {3} gegn sama {2}?
apps/erpnext/erpnext/public/js/controllers/transaction.js +1039,Please set recurring after saving,Vinsamlegast settu endurtekin eftir vistun
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +735,Select change amount account,Veldu breyting upphæð reiknings
DocType: Purchase Invoice,Price List Currency,Verðskrá Gjaldmiðill
DocType: Naming Series,User must always select,Notandi verður alltaf að velja
DocType: Stock Settings,Allow Negative Stock,Leyfa Neikvæð lager
DocType: Installation Note,Installation Note,uppsetning Note
apps/erpnext/erpnext/public/js/setup_wizard.js +221,Add Taxes,Bæta Skattar
DocType: Topic,Topic,Topic
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +40,Cash Flow from Financing,Cash Flow frá fjármögnun
DocType: Budget Account,Budget Account,Budget Account
DocType: Quality Inspection,Verified By,staðfest af
apps/erpnext/erpnext/setup/doctype/company/company.py +67,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Get ekki breytt sjálfgefið mynt félagsins, vegna þess að það eru núverandi viðskiptum. Viðskipti verða að vera lokað til að breyta sjálfgefið mynt."
DocType: Grading Scale Interval,Grade Description,gráðu Lýsing
DocType: Stock Entry,Purchase Receipt No,Kvittun Nei
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,Búa Laun Slip
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,rekjanleiki
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Source of Funds (Liabilities),Uppruni Funds (Skuldir)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +380,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Magn í röð {0} ({1}) verður að vera það sama og framleiddar magn {2}
DocType: Appraisal,Employee,Starfsmaður
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} er að fullu innheimt
DocType: Training Event,End Time,End Time
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +62,Active Salary Structure {0} found for employee {1} for the given dates,Active Laun Uppbygging {0} fannst fyrir starfsmann {1} fyrir gefin dagsetningar
DocType: Payment Entry,Payment Deductions or Loss,Greiðsla Frádráttur eða tap
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Stöðluð samningsskilyrði til sölu eða kaup.
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Group eftir Voucher
apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,velta Pipeline
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +221,Please set default account in Salary Component {0},Vinsamlegast settu sjálfgefin reikningur í laun Component {0}
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Required On
DocType: Rename Tool,File to Rename,Skrá til Endurnefna
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +204,Please select BOM for Item in Row {0},Vinsamlegast veldu BOM fyrir lið í Row {0}
apps/erpnext/erpnext/controllers/buying_controller.py +263,Specified BOM {0} does not exist for Item {1},Tilgreint BOM {0} er ekki til fyrir lið {1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Viðhald Dagskrá {0} verður lokað áður en hætta þessu Velta Order
DocType: Notification Control,Expense Claim Approved,Expense Krafa Samþykkt
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +316,Salary Slip of employee {0} already created for this period,Laun Slip starfsmanns {0} þegar búin á þessu tímabili
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +117,Pharmaceutical,Pharmaceutical
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Kostnaður vegna aðkeyptrar atriði
DocType: Selling Settings,Sales Order Required,Velta Order Required
DocType: Purchase Invoice,Credit To,Credit Til
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Virkar leiðir / Viðskiptavinir
DocType: Employee Education,Post Graduate,Post Graduate
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Viðhald Dagskrá Detail
DocType: Quality Inspection Reading,Reading 9,lestur 9
DocType: Supplier,Is Frozen,er frosinn
apps/erpnext/erpnext/stock/utils.py +194,Group node warehouse is not allowed to select for transactions,Group hnút vöruhús er ekki leyft að velja fyrir viðskipti
DocType: Buying Settings,Buying Settings,Kaup Stillingar
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM Nei fyrir Finished Good Item
DocType: Upload Attendance,Attendance To Date,Aðsókn að Dagsetning
DocType: Warranty Claim,Raised By,hækkaðir um
DocType: Payment Gateway Account,Payment Account,greiðsla Reikningur
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +854,Please specify Company to proceed,Vinsamlegast tilgreinið Company til að halda áfram
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Net Breyta viðskiptakrafna
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +50,Compensatory Off,jöfnunaraðgerðir Off
DocType: Offer Letter,Accepted,Samþykkt
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +25,Organization,Skipulag
DocType: SG Creation Tool Course,Student Group Name,Student Group Name
apps/erpnext/erpnext/setup/doctype/company/company.js +50,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.,Vinsamlegast vertu viss um að þú viljir virkilega að eyða öllum viðskiptum fyrir þetta fyrirtæki. stofngÃ¶gn haldast eins og það er. Þessi aðgerð er ekki hægt að afturkalla.
DocType: Room,Room Number,Room Number
apps/erpnext/erpnext/utilities/transaction_base.py +96,Invalid reference {0} {1},Ógild vísun {0} {1}
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +163,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) getur ekki verið meiri en áætlað quanitity ({2}) í framleiðslu Order {3}
DocType: Shipping Rule,Shipping Rule Label,Sendingar Regla Label
apps/erpnext/erpnext/public/js/conf.js +28,User Forum,User Forum
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +248,Raw Materials cannot be blank.,Hráefni má ekki vera auður.
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +469,"Could not update stock, invoice contains drop shipping item.","Gat ekki uppfært lager, reikningsnúmer inniheldur falla skipum hlut."
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +459,Quick Journal Entry,Quick Journal Entry
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +140,You can not change rate if BOM mentioned agianst any item,Þú getur ekki breytt hlutfall ef BOM getið agianst hvaða atriði
DocType: Employee,Previous Work Experience,Fyrri Starfsreynsla
DocType: Stock Entry,For Quantity,fyrir Magn
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +209,Please enter Planned Qty for Item {0} at row {1},Vinsamlegast sláðu Planned Magn fyrir lið {0} á röð {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} er ekki lögð
apps/erpnext/erpnext/config/stock.py +27,Requests for items.,Beiðnir um atriði.
DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Aðskilið framleiðsla þess verður búin til fyrir hvern fullunna gott lið.
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +126,{0} must be negative in return document,{0} verður að vera neikvætt í staðinn skjal
,Minutes to First Response for Issues,Mínútur til First Response fyrir málefni
DocType: Purchase Invoice,Terms and Conditions1,Skilmálar og Conditions1
apps/erpnext/erpnext/public/js/setup_wizard.js +66,The name of the institute for which you are setting up this system.,The nafn af the Institute sem þú ert að setja upp þetta kerfi.
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Bókhald færsla fryst upp til þessa dagsetningu, enginn getur gert / breyta færslu, nema hlutverki sem tilgreindur er hér."
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Vistaðu skjalið áður kynslóð viðhald áætlun
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Project Status
DocType: UOM,Check this to disallow fractions. (for Nos),Hakaðu við þetta til að banna broti. (NOS)
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +395,The following Production Orders were created:,Eftirfarandi Framleiðslu Pantanir voru búnar:
DocType: Student Admission,Naming Series (for Student Applicant),Nafngiftir Series (fyrir námsmanna umsækjanda)
DocType: Delivery Note,Transporter Name,Flutningsaðili Nafn
DocType: Authorization Rule,Authorized Value,Leyft Value
DocType: BOM,Show Operations,Sýna Aðgerðir
,Minutes to First Response for Opportunity,Mínútur til First Response fyrir Tækifæri
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +58,Total Absent,alls Absent
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +785,Item or Warehouse for row {0} does not match Material Request,Liður eða Warehouse fyrir röð {0} passar ekki Material Beiðni
apps/erpnext/erpnext/config/stock.py +189,Unit of Measure,Mælieining
DocType: Fiscal Year,Year End Date,Ár Lokadagur
DocType: Task Depends On,Task Depends On,Verkefni veltur á
DocType: Supplier Quotation,Opportunity,tækifæri
,Completed Production Orders,Lokið Framleiðsla Pantanir
DocType: Operation,Default Workstation,Sjálfgefið Workstation
DocType: Notification Control,Expense Claim Approved Message,Kostnað Krafa Samþykkt skilaboð
DocType: Payment Entry,Deductions or Loss,Frádráttur eða tap
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} er lokað
DocType: Email Digest,How frequently?,Hversu oft?
DocType: Purchase Receipt,Get Current Stock,Fá núverandi lager
apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Tré Bill of Materials
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +46,Item Code &gt; Item Group &gt; Brand,Vörunúmer&gt; Liðurhópur&gt; Vörumerki
DocType: Student,Joining Date,Tengja Dagsetning
,Employees working on a holiday,Starfsmenn sem vinna í frí
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Present
DocType: Project,% Complete Method,% Complete Aðferð
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +201,Maintenance start date can not be before delivery date for Serial No {0},Viðhald Upphafsdagur getur ekki verið áður fæðingardag fyrir Raðnúmer {0}
DocType: Production Order,Actual End Date,Raunveruleg Lokadagur
DocType: BOM,Operating Cost (Company Currency),Rekstrarkostnaður (Company Gjaldmiðill)
DocType: Purchase Invoice,PINV-,PINV-
DocType: Authorization Rule,Applicable To (Role),Gildir til (Hlutverk)
DocType: Stock Entry,Purpose,Tilgangur
DocType: Company,Fixed Asset Depreciation Settings,Fast eign Afskriftir Stillingar
DocType: Item,Will also apply for variants unless overrridden,Mun einnig gilda um afbrigði nema overrridden
DocType: Purchase Invoice,Advances,framfarir
DocType: Production Order,Manufacture against Material Request,Framleiðsla á móti Material Beiðni
DocType: Item Reorder,Request for,Beiðni um
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Samþykkir notandi getur ekki verið sama og notandinn reglan er við að
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Basic Rate (eins og á lager UOM)
DocType: SMS Log,No of Requested SMS,Ekkert af Beðið um SMS
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,Leave Without Pay does not match with approved Leave Application records,Leyfi án launa passar ekki við viðurkenndar Leave Umsókn færslur
DocType: Campaign,Campaign-.####,Herferð -. ####
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Næstu skref
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +749,Please supply the specified items at the best possible rates,Gefðu tilgreind atriði í besta mögulega verð
DocType: Selling Settings,Auto close Opportunity after 15 days,Auto nálægt Tækifæri eftir 15 daga
apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,árslok
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Quot / Lead%
apps/erpnext/erpnext/hr/doctype/employee/employee.py +119,Contract End Date must be greater than Date of Joining,Samningur Lokadagur verður að vera hærri en Dagsetning Tengja
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.,Þriðji aðili dreifingaraðila / söluaðila / umboðsmanns / tengja / sölumaður sem selur fyrirtæki vörur fyrir þóknun.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} gegn Purchase Order {1}
DocType: SMS Settings,"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Sláðu truflanir vefslóðabreytur hér (td. Sendanda = ERPNext, username = ERPNext, password = 1234 osfrv)"
DocType: Task,Actual Start Date (via Time Sheet),Raunbyrjunardagsetning (með Time Sheet)
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Þetta er dæmi website sjálfvirkt mynda frá ERPNext
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Ageing Range 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.","Standard skatta sniðmát sem hægt er að beita öllum kaupfærslur. Þessi sniðmát geta innihaldið lista yfir skatta höfuð og einnig öðrum forstöðumönnum kostnaðarliði eins og &quot;Shipping&quot;, &quot;tryggingar&quot;, &quot;Meðhöndlun&quot; osfrv #### Athugið skatthlutfall þú velur hér verður staðallinn skatthlutfallið fyrir alla ** Items * *. Ef það eru ** Items ** sem hafa mismunandi verð, verður að bæta við í ** Item Tax ** borð í ** Liður ** meistara. #### Lýsing dálka 1. Útreikningur Type: - Þetta getur verið á ** Net Total ** (sem er summa grunnfjárhæð). - ** Á fyrri umf öllum / Upphæð ** (fyrir uppsöfnuð skatta eða gjöld). Ef þú velur þennan kost, að skattur verði beitt sem hlutfall af fyrri röðinni (í skatt töflu) fjárhæð eða samtals. - ** Raunveruleg ** (eins og getið). 2. Reikningur Head: The Account höfuðbók þar sem þessi skattur verður að bóka 3. Kostnaður Center: Ef skattur / gjald er tekjur (eins skipum) eða gjaldaliði það þarf að bóka á móti kostnaði sent. 4. Lýsing: Lýsing á skatta (sem verður prentað í reikningum / gæsalappa). 5. Gefa: Skatthlutfall. 6. Upphæð: Skatthlutfall. 7. Samtals: Uppsöfnuð alls að þessum tímapunkti. 8. Sláðu Row: Ef byggir á &quot;Fyrri Row Total&quot; getur þú valið línunúmeri sem verður tekið sem grunn fyrir þessum útreikningi (sjálfgefið er fyrri umf). 9. Íhuga skattur eða gjald fyrir: Í þessum kafla er hægt að tilgreina hvort skatturinn / gjald er aðeins fyrir mat (ekki hluti af öllum) eða aðeins fyrir samtals (ekki bæta gildi til hlutnum) eða bæði. 10. Bæta eða draga: Hvort sem þú vilt bæta við eða draga skatt."
DocType: Homepage,Homepage,heimasíða
DocType: Purchase Receipt Item,Recd Quantity,Recd Magn
apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +57,Fee Records Created - {0},Fee Records Búið - {0}
DocType: Asset Category Account,Asset Category Account,Asset Flokkur Reikningur
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +105,Cannot produce more Item {0} than Sales Order quantity {1},Geta ekki framleitt meira ítarefni {0} en Sales Order Magn {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Stock Entry {0} er ekki lögð
DocType: Payment Reconciliation,Bank / Cash Account,Bank / Cash Account
apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Next Contact By cannot be same as the Lead Email Address,Næsta Samband með getur ekki verið sama og Lead netfanginu
DocType: Tax Rule,Billing City,Innheimta City
DocType: Asset,Manual,Manual
DocType: Salary Component Account,Salary Component Account,Laun Component Reikningur
DocType: Global Defaults,Hide Currency Symbol,Fela gjaldmiðilinn
apps/erpnext/erpnext/config/accounts.py +294,"e.g. Bank, Cash, Credit Card","td Bank, Cash, Credit Card"
DocType: Lead Source,Source Name,Source Name
DocType: Journal Entry,Credit Note,Inneignarnótu
DocType: Warranty Claim,Service Address,þjónusta Address
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +47,Furnitures and Fixtures,Húsgögnum og innréttingum
DocType: Item,Manufacture,Framleiðsla
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Vinsamlegast Afhending Note fyrst
DocType: Student Applicant,Application Date,Umsókn Dagsetning
DocType: Salary Detail,Amount based on formula,Upphæð byggist á formúlu
DocType: Purchase Invoice,Currency and Price List,Gjaldmiðill og Verðskrá
DocType: Opportunity,Customer / Lead Name,Viðskiptavinur / Lead Name
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Úthreinsun Date ekki getið
apps/erpnext/erpnext/config/manufacturing.py +7,Production,framleiðsla
DocType: Guardian,Occupation,Atvinna
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Row {0}: Byrja Bætt verður fyrir lokadagsetningu
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Alls (Magn)
DocType: Sales Invoice,This Document,Þetta skjal
DocType: Installation Note Item,Installed Qty,uppsett Magn
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +7,Training Result,Þjálfun Niðurstaða
DocType: Purchase Invoice,Is Paid,er greitt
DocType: Salary Structure,Total Earning,alls earnings
DocType: Purchase Receipt,Time at which materials were received,Tími þar sem efni bárust
DocType: Stock Ledger Entry,Outgoing Rate,Outgoing Rate
apps/erpnext/erpnext/config/hr.py +224,Organization branch master.,Stofnun útibú húsbóndi.
apps/erpnext/erpnext/controllers/accounts_controller.py +290, or ,eða
DocType: Sales Order,Billing Status,Innheimta Staða
apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Tilkynna um vandamál
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Utility Expenses,gagnsemi Útgjöld
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-Above
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +213,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Row # {0}: Journal Entry {1} hefur ekki reikning {2} eða þegar samsvarandi gegn öðrum skírteini
DocType: Buying Settings,Default Buying Price List,Sjálfgefið Buying Verðskrá
DocType: Process Payroll,Salary Slip Based on Timesheet,Laun Slip Byggt á tímaskráningar
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +116,No employee for the above selected criteria OR salary slip already created,Enginn starfsmaður fyrir ofan valin viðmiðunum eða laun miði nú þegar búið
DocType: Notification Control,Sales Order Message,Velta Order Message
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Set Default gildi eins Company, Gjaldmiðill, yfirstandandi reikningsári, o.fl."
DocType: Payment Entry,Payment Type,greiðsla Type
apps/erpnext/erpnext/stock/doctype/batch/batch.py +122,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Vinsamlegast veldu lotu fyrir hlut {0}. Ekki er hægt að finna eina lotu sem uppfyllir þessa kröfu
DocType: Process Payroll,Select Employees,Select Starfsmenn
DocType: Opportunity,Potential Sales Deal,Hugsanleg sala Deal
DocType: Payment Entry,Cheque/Reference Date,Ávísun / Frestdagur
DocType: Purchase Invoice,Total Taxes and Charges,Samtals Skattar og gjöld
DocType: Employee,Emergency Contact,Neyðar Tengiliður
DocType: Bank Reconciliation Detail,Payment Entry,greiðsla Entry
DocType: Item,Quality Parameters,gæði Parameters
,sales-browser,sölu-vafra
apps/erpnext/erpnext/accounts/doctype/account/account.js +56,Ledger,Ledger
DocType: Target Detail,Target  Amount,Target Upphæð
DocType: Shopping Cart Settings,Shopping Cart Settings,Shopping Cart Stillingar
DocType: Journal Entry,Accounting Entries,Bókhalds Færslur
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Afrit Entry. Vinsamlegast athugaðu Heimild Rule {0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +27,Global POS Profile {0} already created for company {1},Global POS Profile {0} þegar búin að fyrirtæki {1}
DocType: Purchase Order,Ref SQ,Ref SQ
apps/erpnext/erpnext/config/manufacturing.py +74,Replace Item / BOM in all BOMs,Skipta Item / BOM í öllum BOMs
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +53,Receipt document must be submitted,Kvittun skjal skal skilað
DocType: Purchase Invoice Item,Received Qty,fékk Magn
DocType: Stock Entry Detail,Serial No / Batch,Serial Nei / Batch
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +310,Not Paid and Not Delivered,Ekki greidd og ekki skilað
DocType: Product Bundle,Parent Item,Parent Item
DocType: Account,Account Type,Tegund reiknings
DocType: Delivery Note,DN-RET-,DN-RET-
apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Enginn tími blöð
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,Skildu Tegund {0} Ekki er hægt að bera-send
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +216,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Viðhald Dagskrá er ekki mynda að öllum þeim atriðum. Vinsamlegast smelltu á &#39;Búa Stundaskrá&#39;
,To Produce,Að framleiða
apps/erpnext/erpnext/config/hr.py +93,Payroll,launaskrá
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Fyrir röð {0} í {1}. Til eru {2} í lið gengi, raðir {3} skal einnig"
apps/erpnext/erpnext/utilities/activation.py +99,Make User,gera notanda
DocType: Packing Slip,Identification of the package for the delivery (for print),Auðkenning pakka fyrir afhendingu (fyrir prentun)
DocType: Bin,Reserved Quantity,frátekin Magn
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Vinsamlegast sláðu inn gilt netfang
apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.js +67,There is no mandatory course for the program {0},Það er engin lögboðin námskeið fyrir forritið {0}
DocType: Landed Cost Voucher,Purchase Receipt Items,Kvittun Items
apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,sérsníða Eyðublöð
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +36,Arrear,Arrear
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Depreciation Amount during the period,Afskriftir Upphæð á tímabilinu
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,Óvirkt sniðmát má ekki vera sjálfgefið sniðmát
DocType: Account,Income Account,tekjur Reikningur
DocType: Payment Request,Amount in customer's currency,Upphæð í mynt viðskiptavinarins
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +779,Delivery,Afhending
DocType: Stock Reconciliation Item,Current Qty,Núverandi Magn
DocType: BOM Item,"See ""Rate Of Materials Based On"" in Costing Section",Sjá &quot;Rate Af efni byggt á&quot; í kosta lið
apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Fyrri
DocType: Appraisal Goal,Key Responsibility Area,Key Ábyrgð Area
apps/erpnext/erpnext/utilities/activation.py +125,"Student Batches help you track attendance, assessments and fees for students","Námsmaður Lotur hjálpa þér að fylgjast með mætingu, mat og gjalda fyrir nemendur"
DocType: Payment Entry,Total Allocated Amount,Samtals úthlutað magn
DocType: Item Reorder,Material Request Type,Efni Beiðni Type
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +273,Accural Journal Entry for salaries from {0} to {1},Accural Journal Entry fyrir laun frá {0} til {1}
apps/erpnext/erpnext/accounts/page/pos/pos.js +778,"LocalStorage is full, did not save","LocalStorage er fullt, ekki spara"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +85,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM viðskipta Factor er nauðsynlegur
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +20,Ref,Ref
DocType: Budget,Cost Center,kostnaður Center
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +36,Voucher #,skírteini #
DocType: Notification Control,Purchase Order Message,Purchase Order skilaboð
DocType: Tax Rule,Shipping Country,Sendingar Country
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Fela Tax Auðkenni viðskiptavinar frá sölu viðskiptum
DocType: Upload Attendance,Upload HTML,Hlaða HTML
DocType: Employee,Relieving Date,létta Dagsetning
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +12,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Verðlagning Regla er gert til að skrifa verðskrá / define afsláttur hlutfall, byggt á einhverjum forsendum."
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Warehouse er einungis hægt að breyta í gegnum Kauphöll Entry / Afhending Note / Kvittun
DocType: Employee Education,Class / Percentage,Flokkur / Hlutfall
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +96,Head of Marketing and Sales,Forstöðumaður markaðssetning og sala
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +34,Income Tax,Tekjuskattur
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +15,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Ef valið Verðlagning Regla er gert fyrir &#39;verð&#39;, mun það skrifa verðlista. Verðlagning Regla verð er endanlegt verð, þannig að engin frekari afsláttur ætti að vera beitt. Þess vegna, í viðskiptum eins Velta Order, Purchase Order etc, það verður sótt í &#39;gefa&#39; sviði, frekar en &#39;verðlista gefa&#39; sviði."
apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Track Vísbendingar um Industry tegund.
DocType: Item Supplier,Item Supplier,Liður Birgir
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +423,Please enter Item Code to get batch no,Vinsamlegast sláðu Item Code til að fá lotu nr
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +802,Please select a value for {0} quotation_to {1},Vinsamlegast veldu gildi fyrir {0} quotation_to {1}
apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Öllum vistföngum.
DocType: Company,Stock Settings,lager Stillingar
apps/erpnext/erpnext/accounts/doctype/account/account.py +240,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","Samruni er aðeins mögulegt ef eftirfarandi eiginleikar eru sömu í báðum skrám. Er Group, Root Tegund, Company"
DocType: Vehicle,Electric,Electric
DocType: Task,% Progress,% Progress
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +121,Gain/Loss on Asset Disposal,Hagnaður / tap Asset förgun
DocType: Training Event,Will send an email about the event to employees with status 'Open',Mun senda tölvupóst um atburðinn til starfsmanna með stöðu &#39;Open&#39;
DocType: Task,Depends on Tasks,Fer á Verkefni
apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Stjórna Viðskiptavinur Group Tree.
DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Viðhengi má sjá án þess að gera körfu kleift
DocType: Supplier Quotation,SQTN-,SQTN-
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Nýtt Kostnaður Center Name
DocType: Leave Control Panel,Leave Control Panel,Skildu Control Panel
DocType: Project,Task Completion,verkefni Lokið
apps/erpnext/erpnext/templates/form_grid/stock_entry_grid.html +26,Not in Stock,Ekki til á lager
DocType: Appraisal,HR User,HR User
DocType: Purchase Invoice,Taxes and Charges Deducted,Skattar og gjöld FrÃ¡
apps/erpnext/erpnext/hooks.py +116,Issues,Vandamál
apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Staða verður að vera einn af {0}
DocType: Sales Invoice,Debit To,debet Til
DocType: Delivery Note,Required only for sample item.,Aðeins nauðsynlegt fyrir sýnishorn hlut.
DocType: Stock Ledger Entry,Actual Qty After Transaction,Raunveruleg Magn eftir viðskipti
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +65,No salary slip found between {0} and {1},Engin laun miði fannst á milli {0} og {1}
,Pending SO Items For Purchase Request,Bíður SO Hlutir til kaupa Beiðni
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +29,Student Admissions,Student Innlagnir
apps/erpnext/erpnext/accounts/party.py +339,{0} {1} is disabled,{0} {1} er óvirk
DocType: Supplier,Billing Currency,Innheimta Gjaldmiðill
DocType: Sales Invoice,SINV-RET-,SINV-RET-
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +162,Extra Large,Auka stór
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +58,Total Leaves,Samtals Leaves
,Profit and Loss Statement,Rekstrarreikningur yfirlýsing
DocType: Bank Reconciliation Detail,Cheque Number,ávísun Number
,Sales Browser,velta Browser
DocType: Journal Entry,Total Credit,alls Credit
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Viðvörun: Annar {0} # {1} er til gegn hlutabréfum færslu {2}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +113,Local,Local
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Útlán og kröfur (inneign)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Skuldunautar
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +161,Large,stór
DocType: Homepage Featured Product,Homepage Featured Product,Heimasíðan Valin Vara
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +198,All Assessment Groups,Allir Námsmat Hópar
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Nýtt Warehouse Name
apps/erpnext/erpnext/accounts/report/financial_statements.py +227,Total {0} ({1}),Alls {0} ({1})
DocType: C-Form Invoice Detail,Territory,Territory
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +152,Please mention no of visits required,Vinsamlegast nefna engin heimsókna krafist
DocType: Stock Settings,Default Valuation Method,Sjálfgefið Verðmatsaðferð
DocType: Vehicle Log,Fuel Qty,eldsneyti Magn
DocType: Production Order Operation,Planned Start Time,Planned Start Time
DocType: Course,Assessment,mat
DocType: Payment Entry Reference,Allocated,úthlutað
apps/erpnext/erpnext/config/accounts.py +236,Close Balance Sheet and book Profit or Loss.,Loka Efnahagur og bók hagnaður eða tap.
DocType: Student Applicant,Application Status,Umsókn Status
DocType: Fees,Fees,Gjöld
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Tilgreina Exchange Rate að breyta einum gjaldmiðli í annan
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +149,Quotation {0} is cancelled,Tilvitnun {0} er hætt
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +29,Total Outstanding Amount,Heildarstöðu útistandandi
DocType: Sales Partner,Targets,markmið
DocType: Price List,Price List Master,Verðskrá Master
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Öll sala Viðskipti má tagged móti mörgum ** sölufólk ** þannig að þú getur sett og fylgjast markmið.
,S.O. No.,SO nr
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +165,Please create Customer from Lead {0},Vinsamlegast búa til viðskiptavina frá Lead {0}
DocType: Price List,Applicable for Countries,Gildir fyrir löndum
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Aðeins Skildu Umsóknir með stöðu &quot;Samþykkt&quot; og &quot;Hafnað &#39;er hægt að skila
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +51,Student Group Name is mandatory in row {0},Student Group Name er skylda í röð {0}
DocType: Homepage,Products to be shown on website homepage,Vörur birtist á heimasíðu heimasíðuna
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Þetta er rót viðskiptavinur hóp og ekki hægt að breyta.
DocType: Employee,AB-,vinnu í þrjá
DocType: POS Profile,Ignore Pricing Rule,Hunsa Verðlagning reglu
DocType: Employee Education,Graduate,Útskrifast
DocType: Leave Block List,Block Days,blokk Days
DocType: Journal Entry,Excise Entry,vörugjöld Entry
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +69,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Viðvörun: Velta Order {0} er þegar til staðar á móti Purchase Order viðskiptavinar {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.","Staðlaðar Skilmálar og skilyrði sem hægt er að bæta við sölu og innkaup. Dæmi: 1. Gildi tilboðinu. 1. Greiðsluskilmálar (fyrirfram, á lánsfé, hluti fyrirfram etc). 1. Hvað er aukinn (eða ber að greiða viðskiptamanni). 1. Öryggi / notkun viðvörun. 1. Ábyrgð ef einhver er. 1. Skilareglur. 1. Skilmálar skipum, ef við á. 1. Leiðir sem fjallað deilur bætur, ábyrgð osfrv 1. Heimilisfang og Hafa fyrirtækisins."
DocType: Attendance,Leave Type,Leave Type
DocType: Purchase Invoice,Supplier Invoice Details,Birgir Reikningsyfirlit
apps/erpnext/erpnext/controllers/stock_controller.py +235,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Kostnað / Mismunur reikning ({0}) verður að vera &#39;rekstrarreikning &quot;reikning a
DocType: Project,Copied From,Afritað frá
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +91,Name error: {0},Nafn villa: {0}
apps/erpnext/erpnext/stock/doctype/item/item_list.js +8,Shortage,skortur
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +188,{0} {1} does not associated with {2} {3},{0} {1} er ekki tengd við {2} {3}
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Mæting fyrir starfsmann {0} er þegar merkt
DocType: Packing Slip,If more than one package of the same type (for print),Ef fleiri en einn pakka af sömu gerð (fyrir prentun)
,Salary Register,laun Register
DocType: Warehouse,Parent Warehouse,Parent Warehouse
DocType: C-Form Invoice Detail,Net Total,Net Total
apps/erpnext/erpnext/config/hr.py +163,Define various loan types,Skilgreina ýmsar tegundir lána
DocType: Bin,FCFS Rate,FCFS Rate
DocType: Payment Reconciliation Invoice,Outstanding Amount,útistandandi fjárhæð
apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Tími (í mín)
DocType: Project Task,Working,Vinna
DocType: Stock Ledger Entry,Stock Queue (FIFO),Stock Biðröð (FIFO)
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +39,{0} does not belong to Company {1},{0} ekki tilheyra félaginu {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +119,Cost as on,Kostnaður og á
DocType: Account,Round Off,umferð Off
,Requested Qty,Umbeðin Magn
DocType: Tax Rule,Use for Shopping Cart,Nota fyrir Shopping Cart
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},Gildi {0} fyrir eigind {1} er ekki til á lista yfir gild lið eigindar í lið {2}
DocType: BOM Item,Scrap %,rusl%
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +45,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Gjöld verður dreift hlutfallslega miðað hlut Fjöldi eða magn, eins og á val þitt"
DocType: Maintenance Visit,Purposes,tilgangi
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +110,Atleast one item should be entered with negative quantity in return document,Atleast eitt atriði skal færa með neikvæðum magni í staðinn skjal
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","Operation {0} lengur en öllum tiltækum vinnutíma í vinnustöð {1}, brjóta niður rekstur í mörgum aðgerðum"
,Requested,Umbeðin
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,No Remarks,engar athugasemdir
DocType: Purchase Invoice,Overdue,tímabært
DocType: Account,Stock Received But Not Billed,Stock mótteknar En ekki skuldfærður
apps/erpnext/erpnext/accounts/doctype/account/account.py +88,Root Account must be a group,Rót Reikningur verður að vera hópur
DocType: Fees,FEE.,FEE.
DocType: Employee Loan,Repaid/Closed,Launað / Lokað
DocType: Item,Total Projected Qty,Alls spáð Magn
DocType: Monthly Distribution,Distribution Name,Dreifing Name
DocType: Course,Course Code,Auðvitað Code
apps/erpnext/erpnext/controllers/stock_controller.py +333,Quality Inspection required for Item {0},Quality Inspection krafist fyrir lið {0}
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Gengi sem viðskiptavinurinn er mynt er breytt í grunngj.miðil félagsins
DocType: Purchase Invoice Item,Net Rate (Company Currency),Net Rate (Company Gjaldmiðill)
DocType: Salary Detail,Condition and Formula Help,Ástand og Formula Hjálp
apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Stjórna Territory Tree.
DocType: Journal Entry Account,Sales Invoice,Reikningar
DocType: Journal Entry Account,Party Balance,Party Balance
apps/erpnext/erpnext/accounts/page/pos/pos.js +461,Please select Apply Discount On,Vinsamlegast veldu Virkja afsláttur á
DocType: Company,Default Receivable Account,Sjálfgefið Krafa Reikningur
DocType: Process Payroll,Create Bank Entry for the total salary paid for the above selected criteria,Búa Bank færslu fyrir heildarlaunum greitt fyrir ofan valin forsendum
DocType: Stock Entry,Material Transfer for Manufacture,Efni Transfer fyrir Framleiðsla
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +18,Discount Percentage can be applied either against a Price List or for all Price List.,Afsláttur Hlutfall hægt að beita annaðhvort á móti verðskrá eða fyrir alla verðlista.
DocType: Purchase Invoice,Half-yearly,Hálfsárs
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +398,Accounting Entry for Stock,Bókhalds Færsla fyrir Lager
DocType: Vehicle Service,Engine Oil,Vélarolía
DocType: Sales Invoice,Sales Team1,velta TEAM1
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +39,Item {0} does not exist,Liður {0} er ekki til
DocType: Sales Invoice,Customer Address,viðskiptavinur Address
DocType: Employee Loan,Loan Details,lán Nánar
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Completed Qty must be greater than zero.,Row {0}: Lokið Magn verður að vera hærri en núll.
DocType: Purchase Invoice,Apply Additional Discount On,Berið Viðbótarupplýsingar afsláttur á
DocType: Account,Root Type,Root Type
DocType: Item,FIFO,FIFO
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131,Row # {0}: Cannot return more than {1} for Item {2},Row # {0}: Get ekki skila meira en {1} fyrir lið {2}
apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +31,Plot,Söguþráður
DocType: Item Group,Show this slideshow at the top of the page,Sýna þessa myndasýningu efst á síðunni
DocType: BOM,Item UOM,Liður UOM
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Skatthlutfall Eftir Afsláttur Upphæð (Company Gjaldmiðill)
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +149,Target warehouse is mandatory for row {0},Target vöruhús er nauðsynlegur fyrir röð {0}
DocType: Cheque Print Template,Primary Settings,Primary Stillingar
DocType: Purchase Invoice,Select Supplier Address,Veldu Birgir Address
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +371,Add Employees,Bæta Starfsmenn
DocType: Purchase Invoice Item,Quality Inspection,Quality Inspection
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +158,Extra Small,Extra Small
DocType: Company,Standard Template,Standard Template
DocType: Training Event,Theory,Theory
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +757,Warning: Material Requested Qty is less than Minimum Order Qty,Viðvörun: Efni Umbeðin Magn er minna en Minimum Order Magn
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Reikningur {0} er frosinn
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Lögaðili / Dótturfélag með sérstakri Mynd af reikninga tilheyra stofnuninni.
DocType: Payment Request,Mute Email,Mute Email
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +29,"Food, Beverage & Tobacco","Matur, drykkir og Tobacco"
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +623,Can only make payment against unbilled {0},Getur aðeins gera greiðslu gegn ógreitt {0}
apps/erpnext/erpnext/controllers/selling_controller.py +127,Commission rate cannot be greater than 100,hlutfall Framkvæmdastjórnin getur ekki verið meiri en 100
DocType: Stock Entry,Subcontract,undirverktaka
apps/erpnext/erpnext/public/js/utils/party.js +161,Please enter {0} first,Vinsamlegast sláðu inn {0} fyrst
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +64,No replies from,Engin svör frá
DocType: Production Order Operation,Actual End Time,Raunveruleg Lokatími
DocType: Production Planning Tool,Download Materials Required,Sækja efni sem þarf
DocType: Item,Manufacturer Part Number,Framleiðandi Part Number
DocType: Production Order Operation,Estimated Time and Cost,Áætlaður tími og kostnaður
DocType: Bin,Bin,Bin
DocType: SMS Log,No of Sent SMS,Ekkert af Sendir SMS
DocType: Account,Expense Account,Expense Reikningur
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,hugbúnaður
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +165,Colour,Colour
DocType: Assessment Plan Criteria,Assessment Plan Criteria,Mat Plan Viðmið
DocType: Training Event,Scheduled,áætlunarferðir
apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Beiðni um tilvitnun.
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",Vinsamlegast veldu Hlutir sem &quot;Er Stock Item&quot; er &quot;Nei&quot; og &quot;Er Velta Item&quot; er &quot;já&quot; og það er engin önnur vara Bundle
DocType: Student Log,Academic,Academic
apps/erpnext/erpnext/controllers/accounts_controller.py +486,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Total fyrirfram ({0}) gegn Order {1} er ekki vera meiri en GRAND Samtals ({2})
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Veldu Hlaupa dreifingu til ójafnt dreifa skotmörk yfir mánuði.
DocType: Purchase Invoice Item,Valuation Rate,verðmat Rate
DocType: Stock Reconciliation,SR/,SR /
DocType: Vehicle,Diesel,Diesel
apps/erpnext/erpnext/stock/get_item_details.py +318,Price List Currency not selected,Verðlisti Gjaldmiðill ekki valinn
,Student Monthly Attendance Sheet,Student Monthly Aðsókn Sheet
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +185,Employee {0} has already applied for {1} between {2} and {3},Starfsmaður {0} hefur þegar sótt um {1} milli {2} og {3}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Project Start Date
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +11,Until,þangað
DocType: Rename Tool,Rename Log,endurnefna Innskráning
apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Nemandi hópur eða námskeiði er skylt
DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Halda Innheimtustillingar Hours og vinnutími sama á tímaskráningar
DocType: Maintenance Visit Purpose,Against Document No,Against Document nr
DocType: BOM,Scrap,rusl
apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Stjórna Velta Partners.
DocType: Quality Inspection,Inspection Type,skoðun Type
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +237,Warehouses with existing transaction can not be converted to group.,Vöruhús með núverandi viðskipti er ekki hægt að breyta í hópinn.
DocType: Assessment Result Tool,Result HTML,niðurstaða HTML
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,rennur út
apps/erpnext/erpnext/utilities/activation.py +115,Add Students,Bæta Nemendur
apps/erpnext/erpnext/controllers/recurring_document.py +169,Please select {0},Vinsamlegast veldu {0}
DocType: C-Form,C-Form No,C-Form Nei
DocType: BOM,Exploded_items,Exploded_items
DocType: Employee Attendance Tool,Unmarked Attendance,ómerkt Aðsókn
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +99,Researcher,Rannsóknarmaður
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Program Innritun Tool Student
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Nafn eða netfang er nauðsynlegur
apps/erpnext/erpnext/config/stock.py +163,Incoming quality inspection.,Komandi gæði skoðun.
DocType: Purchase Order Item,Returned Qty,Kominn Magn
DocType: Employee,Exit,Hætta
apps/erpnext/erpnext/accounts/doctype/account/account.py +160,Root Type is mandatory,Root Type er nauðsynlegur
DocType: BOM,Total Cost(Company Currency),Total Cost (Company Gjaldmiðill)
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +295,Serial No {0} created,Serial Nei {0} búin
DocType: Homepage,Company Description for website homepage,Fyrirtæki Lýsing á heimasíðu heimasíðuna
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Fyrir þægindi viðskiptavina, þessi númer er hægt að nota á prenti sniðum eins reikninga og sending minnismiða"
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,suplier Name
DocType: Sales Invoice,Time Sheet List,Tími Sheet List
DocType: Employee,You can enter any date manually,Þú getur slegið inn hvaða dagsetningu handvirkt
DocType: Asset Category Account,Depreciation Expense Account,Afskriftir kostnað reiknings
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +183,Probationary Period,reynslutíma
DocType: Customer Group,Only leaf nodes are allowed in transaction,Aðeins blaða hnútar mega í viðskiptum
DocType: Expense Claim,Expense Approver,Expense samþykkjari
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Row {0}: Advance gegn Viðskiptavinur verður að vera trúnaður
apps/erpnext/erpnext/accounts/doctype/account/account.js +66,Non-Group to Group,Non-Group til Group
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +57,Batch is mandatory in row {0},Hópur er nauðsynlegur í röð {0}
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Kvittun Item Staðar
DocType: Payment Entry,Pay,Greitt
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,til DATETIME
DocType: SMS Settings,SMS Gateway URL,SMS Gateway URL
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +54,Course Schedules deleted:,Course Skrár eytt:
apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Logs fyrir að viðhalda SMS-sendingar stöðu
DocType: Accounts Settings,Make Payment via Journal Entry,Greiða í gegnum dagbókarfærslu
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77,Printed On,Prentað á
DocType: Item,Inspection Required before Delivery,Skoðun Áskilið fyrir fæðingu
DocType: Item,Inspection Required before Purchase,Skoðun Áskilið áður en kaupin
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,bið Starfsemi
DocType: Fee Component,Fees Category,Gjald Flokkur
apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Please enter relieving date.,Vinsamlegast sláðu létta dagsetningu.
apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Sláðu inn heiti herferðarinnar ef uppspretta rannsókn er herferð
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +38,Newspaper Publishers,dagblað Publishers
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +31,Select Fiscal Year,Veldu Fiscal Year
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Uppröðun Level
DocType: Company,Chart Of Accounts Template,Mynd af reikningum sniðmáti
DocType: Attendance,Attendance Date,Aðsókn Dagsetning
apps/erpnext/erpnext/stock/get_item_details.py +282,Item Price updated for {0} in Price List {1},Item Verð uppfærð fyrir {0} í verðskrá {1}
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Laun Breakup byggt á launin og frádráttur.
apps/erpnext/erpnext/accounts/doctype/account/account.py +132,Account with child nodes cannot be converted to ledger,Reikningur með hnúta barn er ekki hægt að breyta í höfuðbók
DocType: Purchase Invoice Item,Accepted Warehouse,Samþykkt vöruhús
DocType: Bank Reconciliation Detail,Posting Date,staða Date
DocType: Item,Valuation Method,Verðmatsaðferð
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Mark Half Day
DocType: Sales Invoice,Sales Team,velta Team
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +85,Duplicate entry,afrit færslu
DocType: Program Enrollment Tool,Get Students,fá Nemendur
DocType: Serial No,Under Warranty,undir ábyrgð
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +511,[Error],[Villa]
DocType: Sales Order,In Words will be visible once you save the Sales Order.,Í orðum verður sýnileg þegar þú hefur vistað Velta Order.
,Employee Birthday,starfsmaður Afmæli
DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Student Hópur Aðsókn Tool
apps/erpnext/erpnext/controllers/status_updater.py +199,Limit Crossed,Limit Crossed
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.,An fræðihugtak með þessu &quot;skólaárinu &#39;{0} og&#39; Term Name &#39;{1} er þegar til. Vinsamlegast breyttu þessum færslum og reyndu aftur.
apps/erpnext/erpnext/stock/doctype/item/item.py +467,"As there are existing transactions against item {0}, you can not change the value of {1}",Eins og það eru núverandi reiðufé gegn færslu {0} er ekki hægt að breyta gildi {1}
DocType: UOM,Must be Whole Number,Verður að vera heil tala
DocType: Leave Control Panel,New Leaves Allocated (In Days),Ný Leaves Úthlutað (í dögum)
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serial Nei {0} er ekki til
DocType: Sales Invoice Item,Customer Warehouse (Optional),Viðskiptavinur Warehouse (Valfrjálst)
DocType: Pricing Rule,Discount Percentage,afsláttur Hlutfall
DocType: Payment Reconciliation Invoice,Invoice Number,Reikningsnúmer
DocType: Shopping Cart Settings,Orders,pantanir
DocType: Employee Leave Approver,Leave Approver,Skildu samþykkjari
DocType: Assessment Group,Assessment Group Name,Mat Group Name
DocType: Manufacturing Settings,Material Transferred for Manufacture,Efni flutt til Framleiðendur
DocType: Expense Claim,"A user with ""Expense Approver"" role",A notandi með &quot;Kostnað samþykkjari&quot; hlutverk
DocType: Landed Cost Item,Receipt Document Type,Kvittun Document Type
DocType: Daily Work Summary Settings,Select Companies,Select Stofnanir
,Issued Items Against Production Order,Útgefið Items Against Production Order
DocType: Target Detail,Target Detail,Target Detail
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Allir Jobs
DocType: Sales Order,% of materials billed against this Sales Order,% Af efnum rukkaður gegn þessu Sales Order
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Tímabil Lokar Entry
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Kostnaður Center við núverandi viðskipti er ekki hægt að breyta í hópinn
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +333,Amount {0} {1} {2} {3},Upphæð {0} {1} {2} {3}
DocType: Account,Depreciation,gengislækkun
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Birgir (s)
DocType: Employee Attendance Tool,Employee Attendance Tool,Starfsmaður Aðsókn Tool
DocType: Guardian Student,Guardian Student,Guardian Student
DocType: Supplier,Credit Limit,Skuldfærsluhámark
DocType: Production Plan Sales Order,Salse Order Date,Salse Röð Dagsetning
DocType: Salary Component,Salary Component,laun Component
apps/erpnext/erpnext/accounts/utils.py +493,Payment Entries {0} are un-linked,Greiðsla Færslur {0} eru un-tengd
DocType: GL Entry,Voucher No,skírteini nr
,Lead Owner Efficiency,Lead Owner Efficiency
DocType: Leave Allocation,Leave Allocation,Skildu Úthlutun
DocType: Payment Request,Recipient Message And Payment Details,Viðtakandinn Message og greiðsluskilmálar
DocType: Training Event,Trainer Email,þjálfari Email
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +546,Material Requests {0} created,Efni Beiðnir {0} búnar
DocType: Production Planning Tool,Include sub-contracted raw materials,Fela undirverktaka hráefni
apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Snið af skilmálum eða samningi.
DocType: Purchase Invoice,Address and Contact,Heimilisfang og samband við
DocType: Cheque Print Template,Is Account Payable,Er reikningur Greiðist
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +268,Stock cannot be updated against Purchase Receipt {0},Stock Ekki er hægt að uppfæra á móti kvittun {0}
DocType: Supplier,Last Day of the Next Month,Last Day næsta mánaðar
DocType: Support Settings,Auto close Issue after 7 days,Auto nálægt Issue eftir 7 daga
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}","Leyfi ekki hægt að skipta áður en {0}, sem orlof jafnvægi hefur þegar verið fært sendar í framtíðinni leyfi úthlutun met {1}"
apps/erpnext/erpnext/accounts/party.py +298,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Ath: Vegna / Frestdagur umfram leyfð viðskiptavina kredit dagar eftir {0} dag (s)
apps/erpnext/erpnext/schools/doctype/program/program.js +8,Student Applicant,Student Umsækjandi
DocType: Asset Category Account,Accumulated Depreciation Account,Uppsöfnuðum afskriftum Reikningur
DocType: Stock Settings,Freeze Stock Entries,Frysta lager Entries
DocType: Asset,Expected Value After Useful Life,Væntanlegur Value Eftir gagnlegur líf
DocType: Item,Reorder level based on Warehouse,Uppröðun stigi byggist á Lager
DocType: Activity Cost,Billing Rate,Innheimta Rate
,Qty to Deliver,Magn í Bera
,Stock Analytics,lager Analytics
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +438,Operations cannot be left blank,Aðgerðir geta ekki vera autt
DocType: Maintenance Visit Purpose,Against Document Detail No,Gegn Document Detail No
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +79,Party Type is mandatory,Party Type er nauðsynlegur
DocType: Quality Inspection,Outgoing,Outgoing
DocType: Material Request,Requested For,Umbeðin Fyrir
DocType: Quotation Item,Against Doctype,Against DOCTYPE
apps/erpnext/erpnext/controllers/buying_controller.py +388,{0} {1} is cancelled or closed,{0} {1} er aflýst eða lokaður
DocType: Delivery Note,Track this Delivery Note against any Project,Fylgjast með þessari Delivery Ath gegn hvers Project
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Handbært fé frá fjárfesta
,Is Primary Address,Er Primary Heimilisfang
DocType: Production Order,Work-in-Progress Warehouse,Work-í-gangi Warehouse
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +108,Asset {0} must be submitted,Eignastýring {0} Leggja skal fram
apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +58,Attendance Record {0} exists against Student {1},Aðsókn Record {0} hendi á móti Student {1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Tilvísun # {0} dagsett {1}
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +161,Depreciation Eliminated due to disposal of assets,Afskriftir Féll út vegna ráðstöfunar eigna
apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,stjórna Heimilisföng
DocType: Asset,Item Code,Item Code
DocType: Production Planning Tool,Create Production Orders,Búa Framleiðandi Pantanir
DocType: Serial No,Warranty / AMC Details,Ábyrgð í / AMC Nánar
apps/erpnext/erpnext/schools/doctype/student_group/student_group.js +100,Select students manually for the Activity based Group,Veldu nemendur handvirkt fyrir hópinn sem byggir á starfsemi
DocType: Journal Entry,User Remark,Notandi Athugasemd
DocType: Lead,Market Segment,Market Segment
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +868,Paid Amount cannot be greater than total negative outstanding amount {0},Greiddur Upphæð má ekki vera meiri en heildar neikvæð útistandandi {0}
DocType: Employee Internal Work History,Employee Internal Work History,Starfsmaður Innri Vinna Saga
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +239,Closing (Dr),Lokun (Dr)
DocType: Cheque Print Template,Cheque Size,ávísun Size
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +228,Serial No {0} not in stock,Serial Nei {0} ekki til á lager
apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Tax sniðmát til að selja viðskiptum.
DocType: Sales Invoice,Write Off Outstanding Amount,Skrifaðu Off Útistandandi fjárhæð
DocType: School Settings,Current Academic Year,Núverandi námsár
DocType: Stock Settings,Default Stock UOM,Sjálfgefið Stock UOM
DocType: Asset,Number of Depreciations Booked,Fjöldi Afskriftir Bókað
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Sem starfsmaður láni: {0}
DocType: Landed Cost Item,Receipt Document,kvittun Document
DocType: Production Planning Tool,Create Material Requests,Búa Efni beiðnum
DocType: Employee Education,School/University,Skóli / University
DocType: Payment Request,Reference Details,Tilvísun Upplýsingar
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +59,Expected Value After Useful Life must be less than Gross Purchase Amount,Væntanlegur Value Eftir nýtingartíma verður að vera minna en Gross kaupverði
DocType: Sales Invoice Item,Available Qty at Warehouse,Laus Magn á Lager
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,billed Upphæð
DocType: Asset,Double Declining Balance,Tvöfaldur Minnkandi Balance
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +170,Closed order cannot be cancelled. Unclose to cancel.,Lokað þess geta ekki verið lokað. Unclose að hætta.
DocType: Student Guardian,Father,faðir
apps/erpnext/erpnext/controllers/accounts_controller.py +572,'Update Stock' cannot be checked for fixed asset sale,&#39;Uppfæra Stock&#39; Ekki er hægt að athuga fasta sölu eigna
DocType: Bank Reconciliation,Bank Reconciliation,Bank Sættir
DocType: Attendance,On Leave,Í leyfi
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,fá uppfærslur
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Account {2} ekki tilheyra félaginu {3}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +134,Material Request {0} is cancelled or stopped,Efni Beiðni {0} er aflýst eða henni hætt
apps/erpnext/erpnext/public/js/setup_wizard.js +318,Add a few sample records,Bæta nokkrum sýnishorn skrár
apps/erpnext/erpnext/config/hr.py +301,Leave Management,Skildu Stjórnun
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Group eftir reikningi
DocType: Sales Order,Fully Delivered,Alveg Skilað
DocType: Lead,Lower Income,neðri Tekjur
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +168,Source and target warehouse cannot be same for row {0},Uppspretta og miða vöruhús getur ekki verið það sama fyrir röð {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","Munurinn Reikningur verður að vera Eigna- / Ábyrgðartegund reikningur, þar sem þetta Stock Sáttargjörð er Opening Entry"
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Andvirði lánsins getur ekki verið hærri en Lánsupphæðir {0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +207,Purchase Order number required for Item {0},Innkaupapöntunarnúmeri þarf fyrir lið {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +868,Production Order not created,Framleiðsla Order ekki búin
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',&quot;Frá Dagsetning &#39;verður að vera eftir&#39; Til Dagsetning &#39;
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +29,Cannot change status as student {0} is linked with student application {1},Get ekki breytt stöðu sem nemandi {0} er tengd við beitingu nemandi {1}
DocType: Asset,Fully Depreciated,Alveg afskrifaðar
,Stock Projected Qty,Stock Áætlaðar Magn
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +415,Customer {0} does not belong to project {1},Viðskiptavinur {0} ekki tilheyra verkefninu {1}
DocType: Employee Attendance Tool,Marked Attendance HTML,Marked Aðsókn HTML
apps/erpnext/erpnext/utilities/activation.py +71,"Quotations are proposals, bids you have sent to your customers",Tilvitnanir eru tillögur tilboðum þú sendir til viðskiptavina þinna
DocType: Sales Order,Customer's Purchase Order,Viðskiptavinar Purchase Order
apps/erpnext/erpnext/config/stock.py +112,Serial No and Batch,Serial Nei og Batch
DocType: Warranty Claim,From Company,frá Company
apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +39,Sum of Scores of Assessment Criteria needs to be {0}.,Summa skora á mat Criteria þarf að vera {0}.
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Vinsamlegast settu Fjöldi Afskriftir Bókað
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +91,Value or Qty,Gildi eða Magn
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +397,Productions Orders cannot be raised for:,Productions Pantanir geta ekki hækkað um:
apps/erpnext/erpnext/public/js/setup_wizard.js +304,Minute,Minute
DocType: Purchase Invoice,Purchase Taxes and Charges,Purchase skatta og gjöld
,Qty to Receive,Magn til Fá
DocType: Leave Block List,Leave Block List Allowed,Skildu Block List leyfðar
DocType: Grading Scale Interval,Grading Scale Interval,Flokkun deilingar
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Kostnað Krafa um ökutæki Innskráning {0}
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Afsláttur (%) á Verðskrá Verð með Minni
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +58,All Warehouses,Allir Vöruhús
DocType: Sales Partner,Retailer,Smásali
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +107,Credit To account must be a Balance Sheet account,Inneign á reikninginn verður að vera Efnahagur reikning
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +124,All Supplier Types,Allar Birgir ferðalaga
DocType: Global Defaults,Disable In Words,Slökkva á í orðum
apps/erpnext/erpnext/stock/doctype/item/item.py +45,Item Code is mandatory because Item is not automatically numbered,Item Code er nauðsynlegur vegna þess að hluturinn er ekki sjálfkrafa taldir
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +101,Quotation {0} not of type {1},Tilvitnun {0} ekki af tegund {1}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,Viðhald Dagskrá Item
DocType: Sales Order,%  Delivered,% Skilað
DocType: Production Order,PRO-,PRO
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Bank Overdraft Account,Bank Heimildarlás Account
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Gera Laun Slip
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +28,Browse BOM,Fletta BOM
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +153,Secured Loans,Veðlán
DocType: Purchase Invoice,Edit Posting Date and Time,Edit Staða Dagsetning og tími
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +98,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Vinsamlegast settu Fyrningar tengjast Accounts í eignaflokki {0} eða félaginu {1}
DocType: Academic Term,Academic Year,skólaárinu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +167,Opening Balance Equity,Opnun Balance Equity
DocType: Lead,CRM,CRM
DocType: Appraisal,Appraisal,Úttekt
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +134,Email sent to supplier {0},Tölvupóstur sendur á birgi {0}
DocType: Opportunity,OPTY-,OPTY-
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,Dagsetning er endurtekin
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Leyft Undirritaður
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +215,Leave approver must be one of {0},Skildu samþykkjari verður að vera einn af {0}
DocType: Hub Settings,Seller Email,Seljandi Email
DocType: Project,Total Purchase Cost (via Purchase Invoice),Total Kaup Kostnaður (í gegnum kaupa Reikningar)
DocType: Training Event,Start Time,Byrjunartími
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +278,Select Quantity,Select Magn
DocType: Customs Tariff Number,Customs Tariff Number,Tollskrá Number
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Samþykkir hlutverki getur ekki verið sama og hlutverk reglan er við að
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +65,Unsubscribe from this Email Digest,Segja upp áskrift að þessum tölvupósti Digest
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,skilaboð send
apps/erpnext/erpnext/accounts/doctype/account/account.py +102,Account with child nodes cannot be set as ledger,Reikningur með hnúta barn er ekki hægt að setja eins og höfuðbók
DocType: C-Form,II,II
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Gengi sem Verðskrá mynt er breytt í grunngj.miðil viðskiptavinarins
DocType: Purchase Invoice Item,Net Amount (Company Currency),Net Magn (Company Gjaldmiðill)
DocType: Salary Slip,Hour Rate,Hour Rate
DocType: Stock Settings,Item Naming By,Liður Nöfn By
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Annar Tímabil Lokar Entry {0} hefur verið gert eftir {1}
DocType: Production Order,Material Transferred for Manufacturing,Efni flutt til framleiðslu
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +32,Account {0} does not exists,Reikningur {0} er ekki til
DocType: Project,Project Type,Project Type
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Annaðhvort miða Magn eða miða upphæð er nauðsynlegur.
apps/erpnext/erpnext/config/projects.py +45,Cost of various activities,Kostnaður við ýmiss konar starfsemi
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}","Stilling viðburðir til {0}, þar sem Starfsmannafélag fylgir að neðan sölufólk er ekki með notendanafn {1}"
DocType: Timesheet,Billing Details,Billing Upplýsingar
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +150,Source and target warehouse must be different,Uppspretta og miða vöruhús verður að vera öðruvísi
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Ekki leyft að uppfæra lager viðskipti eldri en {0}
DocType: Purchase Invoice Item,PR Detail,PR Detail
DocType: Sales Order,Fully Billed,Alveg Billed
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +149,Please set default payable account in the employee {0},Vinsamlegast stillt sjálfgefna ber að greiða reikning á starfsmann {0}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Handbært fé
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +127,Delivery warehouse required for stock item {0},Afhending vöruhús krafist fyrir hlutabréfum lið {0}
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Framlegð þyngd pakkans. Venjulega nettóþyngd + umbúðir þyngd. (Til prentunar)
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,Notendur með þetta hlutverk er leyft að setja á frysta reikninga og búa til / breyta bókhaldsfærslum gegn frysta reikninga
DocType: Serial No,Is Cancelled,er Hætt
DocType: Student Group,Group Based On,Hópur byggt á
DocType: Journal Entry,Bill Date,Bill Dagsetning
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Þjónusta Item, Tegund, tíðni og kostnað upphæð er krafist"
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +43,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Jafnvel ef það eru margar Verðlagning Reglur með hæsta forgang, eru þá eftirfarandi innri forgangsmál beitt:"
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +109,Do you really want to Submit all Salary Slip from {0} to {1},Viltu virkilega að leggja fram öll Laun miði frá {0} til {1}
DocType: Cheque Print Template,Cheque Height,ávísun Hæð
DocType: Supplier,Supplier Details,birgir Upplýsingar
DocType: Expense Claim,Approval Status,Staða samþykkis
DocType: Hub Settings,Publish Items to Hub,Birta Hlutir til Hub
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +43,From value must be less than to value in row {0},Frá gildi verður að vera minna en að verðmæti í röð {0}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +144,Wire Transfer,millifærsla
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +132,Check all,Athugaðu alla
DocType: Vehicle Log,Invoice Ref,Invoice Ref
DocType: Purchase Order,Recurring Order,Fastir Order
DocType: Company,Default Income Account,Sjálfgefið Tekjur Reikningur
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +33,Customer Group / Customer,Viðskiptavinur Group / viðskiptavina
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Unclosed Fiscal Years Hagnaður / Tap (Credit)
DocType: Sales Invoice,Time Sheets,Tími Sheets
DocType: Payment Gateway Account,Default Payment Request Message,Default Greiðsla Beiðni skilaboð
DocType: Item Group,Check this if you want to show in website,Hakaðu við þetta ef þú vilt sýna í viðbót
apps/erpnext/erpnext/config/accounts.py +136,Banking and Payments,Bankastarfsemi og greiðslur
,Welcome to ERPNext,Velkomið að ERPNext
apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Leiða til tilvitnun
DocType: Lead,From Customer,frá viðskiptavinar
apps/erpnext/erpnext/demo/setup/setup_data.py +321,Calls,símtöl
DocType: Project,Total Costing Amount (via Time Logs),Total Kosta Magn (með Time Logs)
DocType: Purchase Order Item Supplied,Stock UOM,Stock UOM
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +225,Purchase Order {0} is not submitted,Purchase Order {0} er ekki lögð
DocType: Customs Tariff Number,Tariff Number,gjaldskrá Number
apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,Áætlaðar
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,Serial No {0} does not belong to Warehouse {1},Serial Nei {0} ekki tilheyra Warehouse {1}
apps/erpnext/erpnext/controllers/status_updater.py +163,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Ath: Kerfi mun ekki stöðva yfir fæðingu og yfir-bókun fyrir lið {0} sem magn eða upphæð er 0
DocType: Notification Control,Quotation Message,Tilvitnun Message
DocType: Employee Loan,Employee Loan Application,Starfsmaður lánsumsókn
DocType: Issue,Opening Date,opnun Date
apps/erpnext/erpnext/schools/api.py +69,Attendance has been marked successfully.,Aðsókn hefur verið merkt með góðum árangri.
DocType: Journal Entry,Remark,athugasemd
DocType: Purchase Receipt Item,Rate and Amount,Hlutfall og Magn
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +146,Account Type for {0} must be {1},Reikningur Type fyrir {0} verður að vera {1}
apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Blöð og Holiday
DocType: School Settings,Current Academic Term,Núverandi námsbraut
DocType: Sales Order,Not Billed,ekki borgað
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +147,Both Warehouse must belong to same Company,Bæði Warehouse að tilheyra sama Company
apps/erpnext/erpnext/public/js/templates/contact_list.html +37,No contacts added yet.,Engir tengiliðir bætt við enn.
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Landað Kostnaður skírteini Magn
apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Víxlar hækkaðir um birgja.
DocType: POS Profile,Write Off Account,Skrifaðu Off reikning
apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,afsláttur Upphæð
DocType: Purchase Invoice,Return Against Purchase Invoice,Return Against kaupa Reikningar
DocType: Item,Warranty Period (in days),Ábyrgðartímabilið (í dögum)
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Relation with Guardian1,Tengsl Guardian1
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Handbært fé frá rekstri
apps/erpnext/erpnext/public/js/setup_wizard.js +230,e.g. VAT,td VSK
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Liður 4
DocType: Student Admission,Admission End Date,Aðgangseyrir Lokadagur
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +29,Sub-contracting,Sub-samningagerð
DocType: Journal Entry Account,Journal Entry Account,Journal Entry Reikningur
apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.js +3,Student Group,Student Group
DocType: Shopping Cart Settings,Quotation Series,Tilvitnun Series
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +58,"An item exists with same name ({0}), please change the item group name or rename the item",Atriði til staðar með sama nafni ({0}) skaltu breyta liður heiti hópsins eða endurnefna hlutinn
apps/erpnext/erpnext/accounts/page/pos/pos.js +1903,Please select customer,Vinsamlegast veldu viðskiptavin
DocType: C-Form,I,ég
DocType: Company,Asset Depreciation Cost Center,Eignastýring Afskriftir Kostnaður Center
DocType: Sales Order Item,Sales Order Date,Velta Order Dagsetning
DocType: Sales Invoice Item,Delivered Qty,Skilað Magn
DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.",Ef hakað öll börn hverri framleiðslueiningu atriði verður með í efninu beiðnir.
DocType: Assessment Plan,Assessment Plan,mat Plan
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +90,Warehouse {0}: Company is mandatory,Warehouse {0}: Company er nauðsynlegur
DocType: Stock Settings,Limit Percent,Limit Percent
,Payment Period Based On Invoice Date,Greiðsla Tímabil Byggt á reikningi Dagsetning
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Vantar gjaldeyri Verð fyrir {0}
DocType: Assessment Plan,Examiner,prófdómari
DocType: Student,Siblings,systkini
DocType: Journal Entry,Stock Entry,Stock Entry
DocType: Payment Entry,Payment References,Greiðsla Tilvísanir
DocType: C-Form,C-FORM-,C-FORM-
DocType: Vehicle,Insurance Details,Tryggingar Upplýsingar
DocType: Account,Payable,greiðist
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Vinsamlegast sláðu inn lánstíma
apps/erpnext/erpnext/shopping_cart/cart.py +355,Debtors ({0}),Skuldarar ({0})
DocType: Pricing Rule,Margin,spássía
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,ný Viðskiptavinir
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Gross Profit %,Framlegð%
DocType: Appraisal Goal,Weightage (%),Weightage (%)
DocType: Bank Reconciliation Detail,Clearance Date,úthreinsun Dagsetning
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +62,Gross Purchase Amount is mandatory,Gross Purchase Upphæð er nauðsynlegur
DocType: Lead,Address Desc,Heimilisfang karbósýklískan
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +82,Party is mandatory,Party er nauðsynlegur
DocType: Journal Entry,JV-,JV-
DocType: Topic,Topic Name,Topic Name
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +36,Atleast one of the Selling or Buying must be selected,Atleast einn af selja eða kaupa verður að vera valinn
apps/erpnext/erpnext/public/js/setup_wizard.js +25,Select the nature of your business.,Veldu eðli rekstrar þíns.
apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Hvar framleiðslu aðgerðir eru gerðar.
DocType: Asset Movement,Source Warehouse,Source Warehouse
DocType: Installation Note,Installation Date,uppsetning Dagsetning
apps/erpnext/erpnext/controllers/accounts_controller.py +551,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} ekki tilheyra félaginu {2}
DocType: Employee,Confirmation Date,staðfesting Dagsetning
DocType: C-Form,Total Invoiced Amount,Alls Upphæð á reikningi
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +49,Min Qty can not be greater than Max Qty,Min Magn má ekki vera meiri en Max Magn
DocType: Account,Accumulated Depreciation,uppsöfnuðum afskriftum
DocType: Stock Entry,Customer or Supplier Details,Viðskiptavina eða Birgir Upplýsingar
DocType: Employee Loan Application,Required by Date,Krafist af Dagsetning
DocType: Lead,Lead Owner,Lead Eigandi
DocType: Bin,Requested Quantity,Umbeðin Magn
DocType: Employee,Marital Status,Hjúskaparstaða
DocType: Stock Settings,Auto Material Request,Auto Efni Beiðni
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Laus Hópur Magn á frá vöruhúsi
DocType: Customer,CUST-,CUST-
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Gross Pay - Total Frádráttur - Lán Endurgreiðsla
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +25,Current BOM and New BOM can not be same,Núverandi BOM og New BOM getur ekki verið það sama
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +38,Salary Slip ID,Laun Slip ID
apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date Of Retirement must be greater than Date of Joining,Dagsetning starfsloka verður að vera hærri en Dagsetning Tengja
apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +52,There were errors while scheduling course on :,Það komu upp villur við tímasetningu námskeið á:
DocType: Sales Invoice,Against Income Account,Against þáttatekjum
apps/erpnext/erpnext/controllers/website_list_for_contact.py +90,{0}% Delivered,{0}% Skilað
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +81,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Liður {0}: Pantaði Magn {1} má ekki vera minna en lágmarks röð Fjöldi {2} (sem skilgreindur er í lið).
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Mánaðarleg Dreifing Hlutfall
DocType: Territory,Territory Targets,Territory markmið
DocType: Delivery Note,Transporter Info,Transporter Upplýsingar
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +49,Customer &gt; Customer Group &gt; Territory,Viðskiptavinur&gt; Viðskiptavinahópur&gt; Territory
apps/erpnext/erpnext/accounts/utils.py +500,Please set default {0} in Company {1},Vinsamlegast settu sjálfgefið {0} í félaginu {1}
DocType: Cheque Print Template,Starting position from top edge,Upphafsstöðu frá efstu brún
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +30,Same supplier has been entered multiple times,Sama birgir hefur verið slegið mörgum sinnum
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Gross Hagnaður / Tap
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Purchase Order Item Staðar
apps/erpnext/erpnext/public/js/setup_wizard.js +83,Company Name cannot be Company,Nafn fyrirtækis er ekki hægt Company
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Bréf Heads fyrir prenta sniðmát.
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Titlar til prenta sniðmát td Próformareikningur.
DocType: Student Guardian,Student Guardian,Student Guardian
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +192,Valuation type charges can not marked as Inclusive,Verðmat gerð gjöld geta ekki merkt sem Inclusive
DocType: POS Profile,Update Stock,Uppfæra Stock
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.,Mismunandi UOM að atriðum mun leiða til rangrar (alls) nettóþyngd gildi. Gakktu úr skugga um að nettóþyngd hvern hlut er í sama UOM.
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM Rate
DocType: Asset,Journal Entry for Scrap,Journal Entry fyrir rusl
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Vinsamlegast draga atriði úr afhendingarseðlinum
apps/erpnext/erpnext/accounts/utils.py +470,Journal Entries {0} are un-linked,Journal Entries {0} eru un-tengd
apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Upptaka af öllum samskiptum sem gerð tölvupósti, síma, spjall, heimsókn o.fl."
DocType: Manufacturer,Manufacturers used in Items,Framleiðendur notað í liðum
apps/erpnext/erpnext/accounts/general_ledger.py +145,Please mention Round Off Cost Center in Company,Vinsamlegast nefna Round Off Kostnaður Center í félaginu
DocType: Purchase Invoice,Terms,Skilmálar
DocType: Academic Term,Term Name,Term Name
DocType: Buying Settings,Purchase Order Required,Purchase Order Required
,Item-wise Sales History,Item-vitur Sales History
DocType: Expense Claim,Total Sanctioned Amount,Alls bundnar Upphæð
,Purchase Analytics,kaup Analytics
DocType: Sales Invoice Item,Delivery Note Item,Afhending Note Item
DocType: Expense Claim,Task,verkefni
DocType: Purchase Taxes and Charges,Reference Row #,Tilvísun Row #
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Lotunúmer er nauðsynlegur fyrir lið {0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,Þetta er rót velta manneskja og ekki hægt að breyta.
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. ","Ef valið er, mun gildi sem tilgreint eða reiknað er í þessum hluta ekki stuðla að tekjum eða frádráttum. Hins vegar er það gildi sem hægt er að vísa til af öðrum hlutum sem hægt er að bæta við eða draga frá."
,Stock Ledger,Stock Ledger
apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Gefa: {0}
DocType: Company,Exchange Gain / Loss Account,Gengishagnaður / Rekstrarreikningur
apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Starfsmaður og Mæting
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +78,Purpose must be one of {0},Tilgangurinn verður að vera einn af {0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +117,Fill the form and save it,Fylltu út formið og vista hana
DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,Sæktu skýrslu sem inniheldur allar hráefni með nýjustu birgða stöðu þeirra
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum Community
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Actual qty in stock,Raunverulegur fjöldi á lager
DocType: Homepage,"URL for ""All Products""",URL fyrir &quot;Allar vörur&quot;
DocType: Leave Application,Leave Balance Before Application,Skildu Balance Áður Umsókn
DocType: SMS Center,Send SMS,Senda SMS
DocType: Cheque Print Template,Width of amount in word,Breidd upphæð í orði
DocType: Company,Default Letter Head,Sjálfgefin bréf höfuð
DocType: Purchase Order,Get Items from Open Material Requests,Fá atriði úr Open Efni Beiðnir
DocType: Item,Standard Selling Rate,Standard sölugengi
DocType: Account,Rate at which this tax is applied,Gengi sem þessi skattur er beitt
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +19,Reorder Qty,Uppröðun Magn
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Núverandi Op Atvinna
DocType: Company,Stock Adjustment Account,Stock jöfnunarreikning
apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Afskrifa
DocType: Timesheet Detail,Operation ID,Operation ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","System User (ur) ID. Ef sett, mun það verða sjálfgefið fyrir allar HR eyðublöð."
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: Frá {1}
DocType: Task,depends_on,veltur á
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Nafn nýja reikninginn. Ath: Vinsamlegast bý ekki reikninga fyrir viðskiptavini og birgja
DocType: BOM Replace Tool,BOM Replace Tool,BOM Skipta Tól
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Land vitur sjálfgefið veffang Sniðmát
DocType: Sales Order Item,Supplier delivers to Customer,Birgir skilar til viðskiptavinar
apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Form / Item / {0}) er út af lager
apps/erpnext/erpnext/controllers/recurring_document.py +177,Next Date must be greater than Posting Date,Næsta Dagsetning verður að vera hærri en að senda Dagsetning
apps/erpnext/erpnext/public/js/controllers/transaction.js +970,Show tax break-up,Sýna skattur brjóta upp
apps/erpnext/erpnext/accounts/party.py +301,Due / Reference Date cannot be after {0},Vegna / Reference Dagsetning má ekki vera á eftir {0}
apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Gögn Innflutningur og útflutningur
apps/erpnext/erpnext/accounts/doctype/account/account.py +204,"Stock entries exist against Warehouse {0}, hence you cannot re-assign or modify it","Lager færslur eru á móti Warehouse {0}, þess vegna getur þú ekki farið aftur framselja eða breyta henni"
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +63,No students Found,Engar nemendur Found
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Reikningar Staða Date
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,selja
DocType: Sales Invoice,Rounded Total,Ávalur Total
DocType: Product Bundle,List items that form the package.,Listaatriði sem mynda pakka.
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Hlutfall Úthlutun skal vera jafnt og 100%
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +531,Please select Posting Date before selecting Party,Vinsamlegast veldu dagsetningu birtingar áður en þú velur Party
DocType: Program Enrollment,School House,School House
DocType: Serial No,Out of AMC,Út af AMC
apps/erpnext/erpnext/public/js/utils.js +213,Please select Quotations,Vinsamlegast veldu Tilvitnanir
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Fjöldi Afskriftir bókað getur ekki verið meiri en heildarfjöldi Afskriftir
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Gera Viðhald Heimsókn
apps/erpnext/erpnext/selling/doctype/customer/customer.py +160,Please contact to the user who have Sales Master Manager {0} role,Vinsamlegast hafðu samband við til notanda sem hefur sala Master Manager {0} hlutverki
DocType: Company,Default Cash Account,Sjálfgefið Cash Reikningur
apps/erpnext/erpnext/config/accounts.py +56,Company (not Customer or Supplier) master.,Company (ekki viðskiptamenn eða birgja) skipstjóri.
apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Þetta er byggt á mætingu þessa Student
apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +177,No Students in,Engar nemendur í
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +166,Add more items or open full form,Bæta við fleiri atriði eða opnu fulla mynd
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +108,Please enter 'Expected Delivery Date',Vinsamlegast sláðu inn &#39;áætlaðan fæðingardag&#39;
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +197,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Afhending Skýringar {0} verður lokað áður en hætta þessu Velta Order
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +77,Paid amount + Write Off Amount can not be greater than Grand Total,Greiddur upphæð + afskrifa Upphæð má ekki vera meiri en 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} er ekki gild Batch Símanúmer fyrir lið {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Note: There is not enough leave balance for Leave Type {0},Athugið: Það er ekki nóg leyfi jafnvægi um leyfi Tegund {0}
DocType: Training Event,Seminar,Seminar
DocType: Program Enrollment Fee,Program Enrollment Fee,Program innritunargjöld
DocType: Item,Supplier Items,birgir Items
DocType: Opportunity,Opportunity Type,tækifæri Type
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,ný Company
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Viðskipti er einungis hægt að eytt af skapara félagsins
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.,Rangur fjöldi General Ledger færslur fundust. Þú gætir hafa valið rangt reikning í viðskiptum.
DocType: Employee,Prefered Contact Email,Ákjósanleg Netfang tengiliðar
DocType: Cheque Print Template,Cheque Width,ávísun Breidd
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Sannreyna söluverð lið gegn kaupgengi eða Verðmat Rate
DocType: Program,Fee Schedule,gjaldskrá
DocType: Hub Settings,Publish Availability,birta Availability
DocType: Company,Create Chart Of Accounts Based On,Búa graf af reikningum miðað við
apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date of Birth cannot be greater than today.,Fæðingardagur getur ekki verið meiri en í dag.
,Stock Ageing,Stock Ageing
apps/erpnext/erpnext/schools/doctype/student/student.py +38,Student {0} exist against student applicant {1},Student {0} hendi gegn kæranda nemandi {1}
apps/erpnext/erpnext/projects/doctype/task/task.js +31,Timesheet,Tímatafla
apps/erpnext/erpnext/controllers/accounts_controller.py +245,{0} '{1}' is disabled,{0} &#39;{1}&#39; er óvirk
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Setja sem Open
DocType: Cheque Print Template,Scanned Cheque,skönnuð ávísun
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Senda sjálfvirkar tölvupóst til Tengiliði á Sendi viðskiptum.
DocType: Timesheet,Total Billable Amount,Alls Reikningur Upphæð
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Liður 3
DocType: Purchase Order,Customer Contact Email,Viðskiptavinur samband við Tölvupóstur
DocType: Warranty Claim,Item and Warranty Details,Item og Ábyrgð Details
DocType: Sales Team,Contribution (%),Framlag (%)
apps/erpnext/erpnext/controllers/accounts_controller.py +83,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Ath: Greiðsla Entry verður ekki búið síðan &#39;Cash eða Bank Account &quot;var ekki tilgreint
apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.js +73,Select the Program to fetch mandatory courses.,Veldu forritið til að sækja nauðsynleg námskeið.
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +189,Responsibilities,ábyrgð
DocType: Expense Claim Account,Expense Claim Account,Expense Krafa Reikningur
DocType: Sales Person,Sales Person Name,Velta Person Name
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Vinsamlegast sláðu inn atleast 1 reikning í töflunni
apps/erpnext/erpnext/public/js/setup_wizard.js +189,Add Users,Bæta notendur
DocType: POS Item Group,Item Group,Liður Group
DocType: Item,Safety Stock,Safety Stock
apps/erpnext/erpnext/projects/doctype/task/task.py +53,Progress % for a task cannot be more than 100.,Progress% fyrir verkefni getur ekki verið meira en 100.
DocType: Stock Reconciliation Item,Before reconciliation,áður sátta
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},Til {0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Skattar og gjöld bætt (Company Gjaldmiðill)
apps/erpnext/erpnext/stock/doctype/item/item.py +438,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Liður Tax Row {0} verður að hafa hliðsjón af tegund skatta eða tekjur eða gjöld eða Skuldfæranlegar
DocType: Sales Order,Partly Billed,hluta Billed
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Liður {0} verður að vera fast eign Item
DocType: Item,Default BOM,Sjálfgefið BOM
apps/erpnext/erpnext/setup/doctype/company/company.js +48,Please re-type company name to confirm,Vinsamlega munið gerð nafn fyrirtækis til að staðfesta
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +70,Total Outstanding Amt,Alls Framúrskarandi Amt
DocType: Journal Entry,Printing Settings,prentun Stillingar
DocType: Sales Invoice,Include Payment (POS),Fela Greiðsla (POS)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Alls skuldfærsla verður að vera jöfn Total Credit. Munurinn er {0}
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +11,Automotive,Automotive
DocType: Vehicle,Insurance Company,Tryggingafélag
DocType: Asset Category Account,Fixed Asset Account,Fast Asset Reikningur
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +388,Variable,Variable
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Frá Delivery Note
DocType: Student,Student Email Address,Student Netfang
DocType: Timesheet Detail,From Time,frá Time
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,Á lager:
DocType: Notification Control,Custom Message,Custom Message
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +33,Investment Banking,Fyrirtækjaráðgjöf
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +73,Cash or Bank Account is mandatory for making payment entry,Cash eða Bank Account er nauðsynlegur til að gera greiðslu færslu
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +52,Student Address,Námsmaður Heimilisfang
DocType: Purchase Invoice,Price List Exchange Rate,Verðskrá Exchange Rate
DocType: Purchase Invoice Item,Rate,Gefa
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +66,Intern,Intern
apps/erpnext/erpnext/accounts/page/pos/pos.js +1470,Address Name,netfang Nafn
DocType: Stock Entry,From BOM,frá BOM
DocType: Assessment Code,Assessment Code,mat Code
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +35,Basic,Basic
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Lager viðskipti fyrir {0} eru frystar
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +220,Please click on 'Generate Schedule',Vinsamlegast smelltu á &#39;Búa Stundaskrá&#39;
apps/erpnext/erpnext/config/stock.py +190,"e.g. Kg, Unit, Nos, m","td Kg, Unit, Nos, m"
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,Tilvísunarnúmer er nauðsynlegt ef þú færð viðmiðunardagur
DocType: Bank Reconciliation Detail,Payment Document,greiðsla Document
apps/erpnext/erpnext/hr/doctype/employee/employee.py +110,Date of Joining must be greater than Date of Birth,Dagsetning Tengja verður að vera meiri en Fæðingardagur
DocType: Salary Slip,Salary Structure,laun Uppbygging
DocType: Account,Bank,Bank
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +9,Airline,Airline
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +790,Issue Material,Issue Efni
DocType: Material Request Item,For Warehouse,fyrir Warehouse
DocType: Employee,Offer Date,Tilboð Dagsetning
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Tilvitnun
apps/erpnext/erpnext/accounts/page/pos/pos.js +667,You are in offline mode. You will not be able to reload until you have network.,Þú ert í offline háttur. Þú munt ekki vera fær um að endurhlaða fyrr en þú hefur net.
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +46,No Student Groups created.,Engar Student Groups búin.
DocType: Purchase Invoice Item,Serial No,Raðnúmer
apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Mánaðarlega endurgreiðslu Upphæð má ekki vera meiri en lánsfjárhæð
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +144,Please enter Maintaince Details first,Vinsamlegast sláðu Maintaince Nánar fyrst
DocType: Purchase Invoice,Print Language,Print Tungumál
DocType: Salary Slip,Total Working Hours,Samtals Vinnutíminn
DocType: Stock Entry,Including items for sub assemblies,Þ.mt atriði fyrir undir þingum
apps/erpnext/erpnext/accounts/page/pos/pos.js +1832,Enter value must be positive,Sláðu gildi verður að vera jákvæð
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +102,All Territories,Allir Territories
DocType: Purchase Invoice,Items,atriði
apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +26,Student is already enrolled.,Nemandi er nú skráður.
DocType: Fiscal Year,Year Name,ár Name
DocType: Process Payroll,Process Payroll,aðferð Launaskrá
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +234,There are more holidays than working days this month.,Það eru fleiri frídagar en vinnudögum þessum mánuði.
DocType: Product Bundle Item,Product Bundle Item,Vara Knippi Item
DocType: Sales Partner,Sales Partner Name,Heiti Sales Partner
apps/erpnext/erpnext/hooks.py +111,Request for Quotations,Beiðni um tilvitnanir
DocType: Payment Reconciliation,Maximum Invoice Amount,Hámarks Invoice Amount
DocType: Student Language,Student Language,Student Tungumál
apps/erpnext/erpnext/config/selling.py +23,Customers,viðskiptavinir
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Order / Quot%
DocType: Student Sibling,Institution,stofnun
DocType: Asset,Partially Depreciated,hluta afskrifaðar
DocType: Issue,Opening Time,opnun Time
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Frá og Til dagsetningar krafist
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +46,Securities & Commodity Exchanges,Verðbréf &amp; hrávöru ungmennaskipti
apps/erpnext/erpnext/stock/doctype/item/item.py +630,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Default Mælieiningin fyrir Variant &#39;{0}&#39; verða að vera sama og í sniðmáti &#39;{1}&#39;
DocType: Shipping Rule,Calculate Based On,Reikna miðað við
DocType: Delivery Note Item,From Warehouse,frá Warehouse
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +869,No Items with Bill of Materials to Manufacture,Engar Verk með Bill of Materials að Manufacture
DocType: Assessment Plan,Supervisor Name,Umsjón Name
DocType: Program Enrollment Course,Program Enrollment Course,Forritunarnámskeið
DocType: Purchase Taxes and Charges,Valuation and Total,Verðmat og Total
DocType: Tax Rule,Shipping City,Sendingar City
DocType: Notification Control,Customize the Notification,Sérsníða tilkynningu
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +19,Cash Flow from Operations,Handbært fé frá rekstri
DocType: Sales Invoice,Shipping Rule,Sendingar Regla
DocType: Manufacturer,Limited to 12 characters,Takmarkast við 12 stafi
DocType: Journal Entry,Print Heading,Print fyrirsögn
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Alls má ekki vera núll
DocType: Training Event Employee,Attended,sótti
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,'Dagar frá síðustu pöntun' verður að vera meiri en eða jafnt og núll
DocType: Process Payroll,Payroll Frequency,launaskrá Tíðni
DocType: Asset,Amended From,breytt Frá
apps/erpnext/erpnext/public/js/setup_wizard.js +300,Raw Material,Hrátt efni
DocType: Leave Application,Follow via Email,Fylgdu með tölvupósti
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +53,Plants and Machineries,Plöntur og Machineries
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Skatthlutfall Eftir Afsláttur Upphæð
DocType: Daily Work Summary Settings,Daily Work Summary Settings,Daglegar Stillingar Vinna Yfirlit
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +240,Currency of the price list {0} is not similar with the selected currency {1},Gjaldmiðill verðlista {0} er ekki svipað með gjaldmiðli sem valinn {1}
DocType: Payment Entry,Internal Transfer,innri Transfer
apps/erpnext/erpnext/accounts/doctype/account/account.py +220,Child account exists for this account. You can not delete this account.,Barnið er til fyrir þennan reikning. Þú getur ekki eytt þessum reikningi.
apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Annaðhvort miða Magn eða miða upphæð er nauðsynlegur
apps/erpnext/erpnext/stock/get_item_details.py +516,No default BOM exists for Item {0},Ekkert sjálfgefið BOM er til fyrir lið {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +334,Please select Posting Date first,Vinsamlegast veldu dagsetningu birtingar fyrst
apps/erpnext/erpnext/public/js/account_tree_grid.js +211,Opening Date should be before Closing Date,Opnun Date ætti að vera áður lokadegi
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Vinsamlegast settu upp flokkunarnúmer fyrir þátttöku í gegnum skipulag&gt; Númerakerfi
DocType: Leave Control Panel,Carry Forward,Haltu áfram
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Kostnaður Center við núverandi viðskipti er ekki hægt að breyta í höfuðbók
DocType: Department,Days for which Holidays are blocked for this department.,Dagar sem Frídagar eru læst í þessari deild.
,Produced,framleidd
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +121,Created Salary Slips,Búið Laun laumar
DocType: Item,Item Code for Suppliers,Item Code fyrir birgja
DocType: Issue,Raised By (Email),Vakti By (Email)
DocType: Training Event,Trainer Name,þjálfari Name
DocType: Mode of Payment,General,almennt
apps/erpnext/erpnext/public/js/setup_wizard.js +171,Attach Letterhead,hengja bréfshaus
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Síðasta samskipti
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +346,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Get ekki draga þegar flokkur er fyrir &#39;Verðmat&#39; eða &#39;Verðmat og heildar&#39;
apps/erpnext/erpnext/public/js/setup_wizard.js +222,"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.","Listi skatt höfuð (td VSK, toll etc, þeir ættu að hafa einstaka nöfn) og staðlaðar verð þeirra. Þetta mun búa til staðlaða sniðmát sem þú getur breytt og bætt meira seinna."
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +230,Serial Nos Required for Serialized Item {0},Serial Nos Áskilið fyrir serialized lið {0}
apps/erpnext/erpnext/config/accounts.py +146,Match Payments with Invoices,Passa Greiðslur með Reikningar
DocType: Journal Entry,Bank Entry,Bank Entry
DocType: Authorization Rule,Applicable To (Designation),Gildir til (Tilnefning)
,Profitability Analysis,arðsemi Greining
apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Bæta í körfu
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Group By
DocType: Guardian,Interests,Áhugasvið
apps/erpnext/erpnext/config/accounts.py +267,Enable / disable currencies.,Virkja / slökkva á gjaldmiðla.
DocType: Production Planning Tool,Get Material Request,Fá Material Beiðni
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Postal Expenses,pósti Útgjöld
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Alls (Amt)
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,Skemmtun &amp; Leisure
DocType: Quality Inspection,Item Serial No,Liður Serial Nei
apps/erpnext/erpnext/utilities/activation.py +133,Create Employee Records,Búa Employee Records
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +58,Total Present,alls Present
apps/erpnext/erpnext/config/accounts.py +107,Accounting Statements,bókhald Yfirlýsingar
apps/erpnext/erpnext/public/js/setup_wizard.js +304,Hour,klukkustund
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 Serial Nei getur ekki hafa Warehouse. Warehouse verður að setja af lager Entry eða kvittun
DocType: Lead,Lead Type,Lead Tegund
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Þú hefur ekki heimild til að samþykkja lauf á Block Dagsetningar
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +380,All these items have already been invoiced,Öll þessi atriði hafa þegar verið reikningsfærð
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Getur verið samþykkt af {0}
DocType: Item,Default Material Request Type,Default Efni Beiðni Type
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +7,Unknown,óþekkt
DocType: Shipping Rule,Shipping Rule Conditions,Shipping regla Skilyrði
DocType: BOM Replace Tool,The new BOM after replacement,Hin nýja BOM eftir skipti
apps/erpnext/erpnext/accounts/page/pos/pos.js +635,Point of Sale,Sölustaður
DocType: Payment Entry,Received Amount,fékk Upphæð
DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Búa til fullt magn, hunsa magn þegar á röð"
DocType: Account,Tax,Tax
apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,ekki Marked
DocType: Production Planning Tool,Production Planning Tool,Framleiðsla Planning 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","Ekki er hægt að uppfæra batched Item {0} með því að nota Stock Sátt, heldur nota Stock Entry"
DocType: Quality Inspection,Report Date,skýrsla Dagsetning
DocType: Student,Middle Name,Millinafn
DocType: C-Form,Invoices,reikningar
DocType: Batch,Source Document Name,Heimild skjal Nafn
DocType: Job Opening,Job Title,Starfsheiti
apps/erpnext/erpnext/utilities/activation.py +97,Create Users,Búa notendur
apps/erpnext/erpnext/public/js/setup_wizard.js +304,Gram,Gram
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +393,Quantity to Manufacture must be greater than 0.,Magn á Framleiðsla verður að vera hærri en 0.
apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Heimsókn skýrslu fyrir símtal viðhald.
DocType: Stock Entry,Update Rate and Availability,Update Rate og Framboð
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.,Hlutfall sem þú ert leyft að taka á móti eða afhenda fleiri gegn pantað magn. Til dæmis: Ef þú hefur pantað 100 einingar. og barnabætur er 10% þá er leyft að taka á móti 110 einingar.
DocType: POS Customer Group,Customer Group,viðskiptavinur Group
apps/erpnext/erpnext/stock/doctype/batch/batch.js +108,New Batch ID (Optional),Ný lotunúmer (valfrjálst)
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +193,Expense account is mandatory for item {0},Kostnað reikningur er nauðsynlegur fyrir lið {0}
DocType: BOM,Website Description,Vefsíða Lýsing
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Net breyting á eigin fé
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +162,Please cancel Purchase Invoice {0} first,Vinsamlegast hætta kaupa Reikningar {0} fyrst
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","Netfang verður að vera einstakt, þegar til fyrir {0}"
DocType: Serial No,AMC Expiry Date,AMC Fyrningardagsetning
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +795,Receipt,kvittun
,Sales Register,velta Nýskráning
DocType: Daily Work Summary Settings Company,Send Emails At,Senda póst At
DocType: Quotation,Quotation Lost Reason,Tilvitnun Lost Ástæða
apps/erpnext/erpnext/public/js/setup_wizard.js +14,Select your Domain,Veldu lénið þitt
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +340,Transaction reference no {0} dated {1},Tilvísunarnúmer viðskipta engin {0} dagsett {1}
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Það er ekkert að breyta.
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +117,Summary for this month and pending activities,Samantekt fyrir þennan mánuð og bið starfsemi
DocType: Customer Group,Customer Group Name,Viðskiptavinar Group Name
apps/erpnext/erpnext/public/js/pos/pos.html +100,No Customers yet!,Engar viðskiptavinir ennþá!
apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Sjóðstreymi
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Lánið upphæð mega vera Hámarkslán af {0}
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,License
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462,Please remove this Invoice {0} from C-Form {1},Vinsamlegast fjarlægðu þennan reikning {0} úr 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,Vinsamlegast veldu Yfirfæranlegt ef þú vilt líka að fela jafnvægi fyrra reikningsári er fer að þessu fjárhagsári
DocType: GL Entry,Against Voucher Type,Against Voucher Tegund
DocType: Item,Attributes,Eigindir
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +218,Please enter Write Off Account,Vinsamlegast sláðu afskrifa reikning
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Síðasta Röð Dagsetning
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Reikningur {0} er ekki tilheyrir fyrirtækinu {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +828,Serial Numbers in row {0} does not match with Delivery Note,Raðnúmer í röð {0} samsvarar ekki við Afhendingartilkynningu
DocType: Student,Guardian Details,Guardian Upplýsingar
DocType: C-Form,C-Form,C-Form
apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Mark Mæting fyrir margar starfsmenn
DocType: Vehicle,Chassis No,undirvagn Ekkert
DocType: Payment Request,Initiated,hafin
DocType: Production Order,Planned Start Date,Áætlaðir Start Date
DocType: Serial No,Creation Document Type,Creation Document Type
DocType: Leave Type,Is Encash,er Encash
DocType: Leave Allocation,New Leaves Allocated,Ný Leaves Úthlutað
apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Project-vitur gögn eru ekki í boði fyrir Tilvitnun
DocType: Project,Expected End Date,Væntanlegur Lokadagur
DocType: Budget Account,Budget Amount,Budget Upphæð
DocType: Appraisal Template,Appraisal Template Title,Úttekt Snið Title
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +38,From Date {0} for Employee {1} cannot be before employee's joining Date {2},Frá Dagsetning {0} fyrir Starfsmaður {1} er ekki hægt áður en hann Dagsetning starfsmanns {2}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +107,Commercial,Commercial
DocType: Payment Entry,Account Paid To,Reikningur Greiddur Til
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Parent Item {0} mátt ekki vera Stock Item
apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Allar vörur eða þjónustu.
DocType: Expense Claim,More Details,Nánari upplýsingar
DocType: Supplier Quotation,Supplier Address,birgir 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} Fjárhagsáætlun fyrir reikning {1} gegn {2} {3} er {4}. Það mun fara yfir um {5}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +666,Row {0}# Account must be of type 'Fixed Asset',Row {0} # Reikningur verður að vera af gerðinni &#39;Fast Asset&#39;
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Out Qty,út Magn
apps/erpnext/erpnext/config/accounts.py +283,Rules to calculate shipping amount for a sale,Reglur til að reikna sendingarkostnað upphæð fyrir sölu
apps/erpnext/erpnext/selling/doctype/customer/customer.py +34,Series is mandatory,Series er nauðsynlegur
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,Financial Services
DocType: Student Sibling,Student ID,Student ID
apps/erpnext/erpnext/config/projects.py +40,Types of activities for Time Logs,Tegundir starfsemi fyrir Time Logs
DocType: Tax Rule,Sales,velta
DocType: Stock Entry Detail,Basic Amount,grunnfjárhæð
DocType: Training Event,Exam,Exam
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +433,Warehouse required for stock Item {0},Warehouse krafist fyrir hlutabréfum lið {0}
DocType: Leave Allocation,Unused leaves,ónotuð leyfi
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +154,Cr,cr
DocType: Tax Rule,Billing State,Innheimta State
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +287,Transfer,Transfer
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +197,{0} {1} does not associated with Party Account {2},{0} {1} er ekki tengt við Party reikninginn {2}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +866,Fetch exploded BOM (including sub-assemblies),Ná sprakk BOM (þ.mt undireiningar)
DocType: Authorization Rule,Applicable To (Employee),Gildir til (starfsmaður)
apps/erpnext/erpnext/controllers/accounts_controller.py +123,Due Date is mandatory,Skiladagur er nauðsynlegur
apps/erpnext/erpnext/controllers/item_variant.py +80,Increment for Attribute {0} cannot be 0,Vöxtur fyrir eigind {0} er ekki verið 0
DocType: Journal Entry,Pay To / Recd From,Greiða til / Recd Frá
DocType: Naming Series,Setup Series,skipulag Series
DocType: Payment Reconciliation,To Invoice Date,Til dagsetningu reiknings
DocType: Supplier,Contact HTML,Viltu samband við HTML
,Inactive Customers,óvirka viðskiptamenn
DocType: Landed Cost Voucher,LCV,LCV
DocType: Landed Cost Voucher,Purchase Receipts,Purchase Kvittanir
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +27,How Pricing Rule is applied?,Hvernig Verðlagning Regla er beitt?
DocType: Stock Entry,Delivery Note No,Afhending Note Nei
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",Ef hakað aðeins kaupa efni beiðnir um endanlegar hráefni verður með í efninu beiðnir. Annars Efni Beiðni um atriði foreldri verður búin
DocType: Cheque Print Template,Message to show,Skilaboð til að sýna
DocType: Company,Retail,Smásala
DocType: Attendance,Absent,Absent
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +554,Product Bundle,vara Bundle
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Row {0}: Ógild vísun {1}
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Purchase skatta og gjöld sniðmáti
DocType: Upload Attendance,Download Template,Sækja Snið
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}: Annaðhvort debet- eða kredit upphæð er nauðsynlegt fyrir {2}
DocType: GL Entry,Remarks,athugasemdir
DocType: Payment Entry,Account Paid From,Reikningur greitt frá
DocType: Purchase Order Item Supplied,Raw Material Item Code,Raw Material Item Code
DocType: Journal Entry,Write Off Based On,Skrifaðu Off byggt á
apps/erpnext/erpnext/utilities/activation.py +63,Make Lead,gera Blý
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Print and Stationery,Prenta og Ritföng
DocType: Stock Settings,Show Barcode Field,Sýna Strikamerki Field
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +762,Send Supplier Emails,Senda Birgir póst
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.","Laun þegar unnin fyrir tímabilið milli {0} og {1}, Skildu umsókn tímabil getur ekki verið á milli þessu tímabili."
apps/erpnext/erpnext/config/stock.py +127,Installation record for a Serial No.,Uppsetning met fyrir Raðnúmer
DocType: Guardian Interest,Guardian Interest,Guardian Vextir
apps/erpnext/erpnext/config/hr.py +177,Training,Þjálfun
DocType: Timesheet,Employee Detail,starfsmaður Detail
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Guardian1 Email ID,Forráðamaður1 Netfang
apps/erpnext/erpnext/controllers/recurring_document.py +190,Next Date's day and Repeat on Day of Month must be equal,Dagur næsta degi og endurtaka á Dagur mánaðar verður að vera jöfn
apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Stillingar fyrir heimasíðu heimasíðuna
DocType: Offer Letter,Awaiting Response,bíður svars
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +58,Above,hér að framan
apps/erpnext/erpnext/controllers/item_variant.py +214,Invalid attribute {0} {1},Ógild eiginleiki {0} {1}
DocType: Supplier,Mention if non-standard payable account,Tilgreindu ef ekki staðlað greiðslureikningur
DocType: Salary Slip,Earning & Deduction,Launin &amp; Frádráttur
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,Valfrjálst. Þessi stilling verður notuð til að sía í ýmsum viðskiptum.
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +108,Negative Valuation Rate is not allowed,Neikvætt Verðmat Rate er ekki leyfð
DocType: Holiday List,Weekly Off,Vikuleg Off
DocType: Fiscal Year,"For e.g. 2012, 2012-13","Fyrir td 2012, 2012-13"
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Bráðabirgða Hagnaður / Tap (Credit)
DocType: Sales Invoice,Return Against Sales Invoice,Return Against sölureikningi
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Liður 5
DocType: Serial No,Creation Time,Creation Time
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,heildartekjum
DocType: Sales Invoice,Product Bundle Help,Vara Knippi Hjálp
,Monthly Attendance Sheet,Mánaðarleg Aðsókn Sheet
DocType: Production Order Item,Production Order Item,Framleiðsla Order Item
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +16,No record found,Ekkert fannst
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost of Scrapped Asset,Kostnaður við rifið Eignastýring
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially ordred,hluta ordred
apps/erpnext/erpnext/controllers/stock_controller.py +238,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Kostnaður Center er nauðsynlegur fyrir lið {2}
DocType: Vehicle,Policy No,stefna Nei
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +654,Get Items from Product Bundle,Fá atriði úr Vara Knippi
DocType: Asset,Straight Line,Bein lína
DocType: Project User,Project User,Project User
apps/erpnext/erpnext/stock/doctype/batch/batch.js +59,Split,Skipta
DocType: GL Entry,Is Advance,er Advance
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,Aðsókn Frá Dagsetning og Aðsókn hingað til er nauðsynlegur
apps/erpnext/erpnext/controllers/buying_controller.py +146,Please enter 'Is Subcontracted' as Yes or No,Vinsamlegast sláðu inn &quot;Er undirverktöku&quot; eins já eða nei
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Síðasti samskiptadagur
DocType: Sales Team,Contact No.,Viltu samband við No.
DocType: Bank Reconciliation,Payment Entries,Greiðsla Entries
DocType: Production Order,Scrap Warehouse,rusl Warehouse
DocType: Production Order,Check if material transfer entry is not required,Athugaðu hvort efnisflutningsfærsla sé ekki krafist
DocType: Program Enrollment Tool,Get Students From,Fá nemendur frá
DocType: Hub Settings,Seller Country,Seljandi Country
apps/erpnext/erpnext/config/learn.py +273,Publish Items on Website,Birta Atriði á vefsvæðinu
apps/erpnext/erpnext/utilities/activation.py +124,Group your students in batches,Hópur nemenda þín í lotur
DocType: Authorization Rule,Authorization Rule,Heimildin Regla
DocType: Sales Invoice,Terms and Conditions Details,Skilmálar og skilyrði Nánar
apps/erpnext/erpnext/templates/generators/item.html +85,Specifications,upplýsingar
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Velta Skattar og gjöld Sniðmátsmyndir
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Alls (Credit)
DocType: Repayment Schedule,Payment Date,Greiðsludagur
apps/erpnext/erpnext/stock/doctype/batch/batch.js +102,New Batch Qty,Ný lotunúmer
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +10,Apparel & Accessories,Fatnaður &amp; Aukabúnaður
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Fjöldi Order
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / Banner sem mun sýna á efst á listanum vöru.
DocType: Shipping Rule,Specify conditions to calculate shipping amount,Tilgreina skilyrði til að reikna sendingarkostnað upphæð
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Hlutverk leyft að setja á frysta reikninga &amp; Sýsla Frozen færslur
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,Ekki hægt að umbreyta Kostnaður Center til aðalbók eins og það hefur barnið hnúta
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +47,Opening Value,opnun Value
DocType: Salary Detail,Formula,Formula
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +37,Serial #,Serial #
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Commission on Sales,Þóknun á sölu
DocType: Offer Letter Term,Value / Description,Gildi / Lýsing
apps/erpnext/erpnext/controllers/accounts_controller.py +575,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Row # {0}: Asset {1} er ekki hægt að skila, það er þegar {2}"
DocType: Tax Rule,Billing Country,Innheimta Country
DocType: Purchase Order Item,Expected Delivery Date,Áætlaðan fæðingardag
apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Greiðslu- ekki jafnir fyrir {0} # {1}. Munurinn er {2}.
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +96,Entertainment Expenses,risnu
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +47,Make Material Request,Gera Material Beiðni
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Open Item {0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +205,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Velta Invoice {0} verður aflýst áður en hætta þessu Velta Order
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +60,Age,Aldur
DocType: Sales Invoice Timesheet,Billing Amount,Innheimta Upphæð
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Ógild magn sem tilgreint er fyrir lið {0}. Magn ætti að vera hærri en 0.
apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Umsókn um leyfi.
apps/erpnext/erpnext/accounts/doctype/account/account.py +218,Account with existing transaction can not be deleted,Reikningur með núverandi viðskipti getur ekki eytt
DocType: Vehicle,Last Carbon Check,Síðasta Carbon Athuga
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +100,Legal Expenses,málskostnaðar
DocType: Purchase Invoice,Posting Time,staða Time
DocType: Timesheet,% Amount Billed,% Magn Billed
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +116,Telephone Expenses,Sími Útgjöld
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.,Hakaðu við þetta ef þú vilt að þvinga notendur til að velja röð áður en þú vistar. Það verður ekkert sjálfgefið ef þú athuga þetta.
apps/erpnext/erpnext/stock/get_item_details.py +125,No Item with Serial No {0},Ekkert atriði með Serial nr {0}
DocType: Email Digest,Open Notifications,Opið Tilkynningar
DocType: Payment Entry,Difference Amount (Company Currency),Munurinn Magn (Company Gjaldmiðill)
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +77,Direct Expenses,bein Útgjöld
apps/erpnext/erpnext/controllers/recurring_document.py +213,"{0} is an invalid email address in 'Notification \
						Email Address'",{0} er ógild netfang í &#39;Tilkynning \ netfanginu&#39;
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Ný Tekjur Viðskiptavinur
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Travel Expenses,Ferðakostnaður
DocType: Maintenance Visit,Breakdown,Brotna niður
apps/erpnext/erpnext/controllers/accounts_controller.py +687,Account: {0} with currency: {1} can not be selected,Reikningur: {0} með gjaldeyri: {1} Ekki er hægt að velja
DocType: Bank Reconciliation Detail,Cheque Date,ávísun Dagsetning
apps/erpnext/erpnext/accounts/doctype/account/account.py +55,Account {0}: Parent account {1} does not belong to company: {2},Reikningur {0}: Foreldri reikningur {1} ekki tilheyra fyrirtæki: {2}
DocType: Program Enrollment Tool,Student Applicants,Student Umsækjendur
apps/erpnext/erpnext/setup/doctype/company/company.js +64,Successfully deleted all transactions related to this company!,Eytt öll viðskipti sem tengjast þessu fyrirtæki!
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Eins á degi
DocType: Appraisal,HR,HR
DocType: Program Enrollment,Enrollment Date,innritun Dagsetning
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Probation,reynslulausn
apps/erpnext/erpnext/config/hr.py +115,Salary Components,laun Hluti
DocType: Program Enrollment Tool,New Academic Year,Nýtt skólaár
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +765,Return / Credit Note,Return / Credit Note
DocType: Stock Settings,Auto insert Price List rate if missing,Auto innskotið Verðlisti hlutfall ef vantar
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +28,Total Paid Amount,Samtals greitt upphæð
DocType: Production Order Item,Transferred Qty,flutt Magn
apps/erpnext/erpnext/config/learn.py +11,Navigating,siglingar
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +150,Planning,áætlanagerð
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +16,Issued,Útgefið
DocType: Project,Total Billing Amount (via Time Logs),Total Billing Magn (með Time Logs)
apps/erpnext/erpnext/public/js/setup_wizard.js +306,We sell this Item,Við seljum þennan Item
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +68,Supplier Id,birgir Id
DocType: Payment Request,Payment Gateway Details,Greiðsla Gateway Upplýsingar
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +235,Quantity should be greater than 0,Magn ætti að vera meiri en 0
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,Barn hnútar geta verið aðeins búin undir &#39;group&#39; tegund hnúta
DocType: Leave Application,Half Day Date,Half Day Date
DocType: Academic Year,Academic Year Name,Skólaárinu Name
DocType: Sales Partner,Contact Desc,Viltu samband við Ö
apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Gerð af laufum eins frjálslegur, veikur osfrv"
DocType: Email Digest,Send regular summary reports via Email.,Senda reglulegar skýrslur yfirlit með tölvupósti.
DocType: Payment Entry,PE-,hagvexti
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +243,Please set default account in Expense Claim Type {0},Vinsamlegast settu sjálfgefin reikningur í kostnað kröfutegund {0}
DocType: Assessment Result,Student Name,Student Name
DocType: Brand,Item Manager,Item Manager
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +141,Payroll Payable,launaskrá Greiðist
DocType: Buying Settings,Default Supplier Type,Sjálfgefið Birgir Type
DocType: Production Order,Total Operating Cost,Samtals rekstrarkostnaður
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +168,Note: Item {0} entered multiple times,Ath: Item {0} inn mörgum sinnum
apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Allir Tengiliðir.
apps/erpnext/erpnext/public/js/setup_wizard.js +45,Company Abbreviation,fyrirtæki Skammstöfun
apps/erpnext/erpnext/hr/doctype/employee/employee.py +136,User {0} does not exist,User {0} er ekki til
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +92,Raw material cannot be same as main Item,Hráefni má ekki vera það sama og helstu atriði
DocType: Item Attribute Value,Abbreviation,skammstöfun
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +171,Payment Entry already exists,Greiðsla Entry er þegar til
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Ekki authroized síðan {0} umfram mörk
apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Laun sniðmát húsbóndi.
DocType: Leave Type,Max Days Leave Allowed,Max Days Leave leyfðar
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Setja Tax Regla fyrir körfunni
DocType: Purchase Invoice,Taxes and Charges Added,Skattar og gjöld bætt
,Sales Funnel,velta trekt
apps/erpnext/erpnext/setup/doctype/company/company.py +47,Abbreviation is mandatory,Skammstöfun er nauðsynlegur
DocType: Project,Task Progress,verkefni Progress
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Körfu
,Qty to Transfer,Magn á að flytja
apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Quotes að leiðir eða viðskiptavini.
DocType: Stock Settings,Role Allowed to edit frozen stock,Hlutverk Leyft að breyta fryst lager
,Territory Target Variance Item Group-Wise,Territory Target Dreifni Item Group-Wise
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +105,All Customer Groups,Allir hópar viðskiptavina
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,Uppsafnaður Monthly
apps/erpnext/erpnext/controllers/accounts_controller.py +648,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} er nauðsynlegur. Kannski gjaldeyri færsla er ekki búin fyrir {1} til {2}.
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +39,Tax Template is mandatory.,Tax Snið er nauðsynlegur.
apps/erpnext/erpnext/accounts/doctype/account/account.py +49,Account {0}: Parent account {1} does not exist,Reikningur {0}: Foreldri reikningur {1} er ekki til
DocType: Purchase Invoice Item,Price List Rate (Company Currency),Verðlisti Rate (Company Gjaldmiðill)
DocType: Products Settings,Products Settings,Vörur Stillingar
DocType: Account,Temporary,tímabundin
DocType: Program,Courses,námskeið
DocType: Monthly Distribution Percentage,Percentage Allocation,hlutfall Úthlutun
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +90,Secretary,ritari
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction",Ef öryrkjar &#39;í orðum&#39; sviði mun ekki vera sýnilegur í öllum viðskiptum
DocType: Serial No,Distinct unit of an Item,Greinilegur eining hlut
DocType: Pricing Rule,Buying,Kaup
DocType: HR Settings,Employee Records to be created by,Starfskjör Records að vera búin með
DocType: POS Profile,Apply Discount On,Gilda afsláttur á
,Reqd By Date,Reqd By Date
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Creditors,lánardrottnar
DocType: Assessment Plan,Assessment Name,mat Name
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Row # {0}: Serial Nei er nauðsynlegur
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Liður Wise Tax Nánar
apps/erpnext/erpnext/public/js/setup_wizard.js +45,Institute Abbreviation,Institute Skammstöfun
,Item-wise Price List Rate,Item-vitur Verðskrá Rate
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +896,Supplier Quotation,birgir Tilvitnun
DocType: Quotation,In Words will be visible once you save the Quotation.,Í orðum verður sýnileg þegar þú hefur vistað tilvitnun.
apps/erpnext/erpnext/utilities/transaction_base.py +153,Quantity ({0}) cannot be a fraction in row {1},Magn ({0}) getur ekki verið brot í röð {1}
apps/erpnext/erpnext/schools/doctype/fees/fees.js +26,Collect Fees,innheimta gjald
DocType: Attendance,ATT-,viðhorfin
apps/erpnext/erpnext/stock/doctype/item/item.py +450,Barcode {0} already used in Item {1},Strikamerki {0} nú þegar notuð í lið {1}
DocType: Lead,Add to calendar on this date,Bæta við dagatal á þessum degi
apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Reglur til að bæta sendingarkostnað.
DocType: Item,Opening Stock,opnun Stock
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Viðskiptavinur er krafist
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} er nauðsynlegur fyrir aftur
DocType: Purchase Order,To Receive,Til að taka á móti
apps/erpnext/erpnext/public/js/setup_wizard.js +200,user@example.com,user@example.com
DocType: Employee,Personal Email,Starfsfólk Email
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,alls Dreifni
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Ef þetta er virkt, mun kerfið birta bókhald færslur fyrir birgðum sjálfkrafa."
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +15,Brokerage,Miðlari
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +232,Attendance for employee {0} is already marked for this day,Mæting fyrir starfsmann {0} er þegar merkt fyrir þennan dag
DocType: Production Order Operation,"in Minutes
Updated via 'Time Log'",Fundargerðir Uppfært gegnum &#39;Time Innskráning &quot;
DocType: Customer,From Lead,frá Lead
apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Pantanir út fyrir framleiðslu.
apps/erpnext/erpnext/public/js/account_tree_grid.js +67,Select Fiscal Year...,Veldu fjárhagsársins ...
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +537,POS Profile required to make POS Entry,POS Profile þarf að gera POS Entry
DocType: Program Enrollment Tool,Enroll Students,innritast Nemendur
DocType: Hub Settings,Name Token,heiti Token
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Standard Selja
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +137,Atleast one warehouse is mandatory,Atleast einn vöruhús er nauðsynlegur
DocType: Serial No,Out of Warranty,Út ábyrgðar
DocType: BOM Replace Tool,Replace,Skipta
DocType: Production Order,Unstopped,Unstopped
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} gegn sölureikningi {1}
DocType: Sales Invoice,SINV-,SINV-
DocType: Request for Quotation Item,Project Name,nafn verkefnis
DocType: Customer,Mention if non-standard receivable account,Umtal ef non-staðall nái reikning
DocType: Journal Entry Account,If Income or Expense,Ef tekjur eða gjöld
DocType: Production Order,Required Items,Nauðsynleg Items
DocType: Stock Ledger Entry,Stock Value Difference,Stock Value Mismunur
apps/erpnext/erpnext/config/learn.py +234,Human Resource,Mannauðs
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Greiðsla Sættir Greiðsla
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +36,Tax Assets,skattinneign
DocType: BOM Item,BOM No,BOM Nei
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,Journal Entry {0} hefur ekki reikning {1} eða þegar samsvarandi á móti öðrum skírteini
DocType: Item,Moving Average,Moving Average
DocType: BOM Replace Tool,The BOM which will be replaced,The BOM sem verður skipt út
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Electronic Equipments,rafræn útbúnaður
DocType: Account,Debit,debet
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"Leaves verður úthlutað margfeldi af 0,5"
DocType: Production Order,Operation Cost,Operation Kostnaður
apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Hlaða mætingu úr .csv skrá
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,Framúrskarandi Amt
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Setja markmið Item Group-vitur fyrir þetta velta manneskja.
DocType: Stock Settings,Freeze Stocks Older Than [Days],Frysta Stocks eldri en [Days]
apps/erpnext/erpnext/controllers/accounts_controller.py +545,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset er nauðsynlegur fyrir fast eign kaup / sölu
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +40,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Ef tveir eða fleiri Verðlagning Reglur finnast miðað við ofangreindar aðstæður, Forgangur er beitt. Forgangur er fjöldi milli 0 til 20 en Sjálfgefið gildi er núll (auður). Hærri tala þýðir að það mun hafa forgang ef það eru margar Verðlagning Reglur með sömu skilyrðum."
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Fiscal Year: {0} er ekki til
DocType: Currency Exchange,To Currency,til Gjaldmiðill
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Leyfa eftirfarandi notendum að samþykkja yfirgefa Umsóknir um blokk daga.
apps/erpnext/erpnext/config/hr.py +132,Types of Expense Claim.,Tegundir kostnað kröfu.
apps/erpnext/erpnext/controllers/selling_controller.py +173,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Salahlutfall fyrir atriði {0} er lægra en {1} þess. Sala ætti að vera að minnsta kosti {2}
DocType: Item,Taxes,Skattar
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +314,Paid and Not Delivered,Greitt og ekki afhent
DocType: Project,Default Cost Center,Sjálfgefið Kostnaður Center
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +205,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vinsamlegast settu Nafngerðaröð fyrir {0} í gegnum Skipulag&gt; Stillingar&gt; Nöfnunarröð
DocType: Bank Guarantee,End Date,Lokadagur
apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,lager Viðskipti
DocType: Budget,Budget Accounts,Budget reikningar
DocType: Employee,Internal Work History,Innri Vinna Saga
DocType: Depreciation Schedule,Accumulated Depreciation Amount,Uppsöfnuðum afskriftum Upphæð
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Private Equity
DocType: Employee Loan,Fully Disbursed,Alveg afgreiddi
DocType: Maintenance Visit,Customer Feedback,viðskiptavinur Feedback
DocType: Account,Expense,Expense
apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.js +34,Score cannot be greater than Maximum Score,Score getur ekki verið meiri en hámarks stig
DocType: Item Attribute,From Range,frá Range
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +93,Syntax error in formula or condition: {0},Málskipanarvilla í formúlu eða ástandi: {0}
DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Daily Work Yfirlit Stillingar Company
apps/erpnext/erpnext/stock/utils.py +100,Item {0} ignored since it is not a stock item,Liður {0} hunsuð þar sem það er ekki birgðir atriði
DocType: Appraisal,APRSL,APRSL
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +40,Submit this Production Order for further processing.,Senda þessari framleiðslu Raða til frekari vinnslu.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +21,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Að ekki um Verðlagning reglunni í tilteknu viðskiptum, öll viðeigandi Verðlagning Reglur ætti að vera óvirk."
DocType: Assessment Group,Parent Assessment Group,Parent Mat Group
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Störf
,Sales Order Trends,Velta Order Trends
DocType: Employee,Held On,Hélt í
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +36,Production Item,framleiðsla Item
,Employee Information,starfsmaður Upplýsingar
apps/erpnext/erpnext/public/js/setup_wizard.js +232,Rate (%),Hlutfall (%)
DocType: Stock Entry Detail,Additional Cost,aukakostnaðar
apps/erpnext/erpnext/public/js/setup_wizard.js +62,Financial Year End Date,Fjárhagsár Lokadagur
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"Can not filter based on Voucher No, if grouped by Voucher",Getur ekki síað byggð á skírteini nr ef flokkaðar eftir skírteini
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +784,Make Supplier Quotation,Gera Birgir Tilvitnun
DocType: Quality Inspection,Incoming,Komandi
DocType: BOM,Materials Required (Exploded),Efni sem þarf (Sprakk)
apps/erpnext/erpnext/public/js/setup_wizard.js +190,"Add users to your organization, other than yourself","Bæta við notendum til fyrirtækisins, annarra en sjálfur"
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,Staða Dagsetning má ekki vera liðinn
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} passar ekki við {2} {3}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +48,Casual Leave,Kjóll Leave
DocType: Batch,Batch ID,hópur ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Ath: {0}
,Delivery Note Trends,Afhending Ath Trends
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,This Week's Summary,Samantekt Í þessari viku er
,In Stock Qty,Á lager Magn
apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Reikningur: {0} Aðeins er hægt að uppfæra í gegnum lager Viðskipti
DocType: Program Enrollment,Get Courses,fá Námskeið
DocType: GL Entry,Party,Party
DocType: Sales Order,Delivery Date,Afhendingardagur
DocType: Opportunity,Opportunity Date,tækifæri Dagsetning
DocType: Purchase Receipt,Return Against Purchase Receipt,Return Against kvittun
DocType: Request for Quotation Item,Request for Quotation Item,Beiðni um Tilvitnun Item
DocType: Purchase Order,To Bill,Bill
DocType: Material Request,% Ordered,% Pantaði
DocType: Purchase Invoice,"Enter Email Address separated by commas, invoice will be mailed automatically on particular date","Sláðu inn netfangið aðskilin með kommum, reikningur verður sent sjálfkrafa tilteknum degi"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +65,Piecework,ákvæðisvinnu
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Avg. Buying Rate,Avg. kaupgengi
DocType: Task,Actual Time (in Hours),Tíminn (í klst)
DocType: Employee,History In Company,Saga In Company
apps/erpnext/erpnext/config/learn.py +107,Newsletters,Fréttabréf
DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Entry
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +87,Same item has been entered multiple times,Sama atriði hefur verið gert mörgum sinnum
DocType: Department,Leave Block List,Skildu Block List
DocType: Sales Invoice,Tax ID,Tax ID
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +188,Item {0} is not setup for Serial Nos. Column must be blank,Liður {0} er ekki skipulag fyrir Serial Nos. Column verður auður
DocType: Accounts Settings,Accounts Settings,reikninga Stillingar
apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +7,Approve,samþykkja
DocType: Customer,Sales Partner and Commission,Velta Partner og framkvæmdastjórnarinnar
DocType: Employee Loan,Rate of Interest (%) / Year,Vextir (%) / Ár
,Project Quantity,Project Magn
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +73,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Alls {0} á öllum hlutum er núll, getur verið að þú ættir að breyta &#39;Úthluta Gjöld Byggt á&#39;"
DocType: Opportunity,To Discuss,Að ræða
apps/erpnext/erpnext/stock/stock_ledger.py +368,{0} units of {1} needed in {2} to complete this transaction.,{0} einingar {1} þörf {2} að ljúka þessari færslu.
DocType: Loan Type,Rate of Interest (%) Yearly,Rate of Interest (%) Árleg
DocType: SMS Settings,SMS Settings,SMS-stillingar
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +69,Temporary Accounts,tímabundin reikningar
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +169,Black,Black
DocType: BOM Explosion Item,BOM Explosion Item,BOM Sprenging Item
DocType: Account,Auditor,endurskoðandi
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +62,{0} items produced,{0} atriði framleitt
DocType: Cheque Print Template,Distance from top edge,Fjarlægð frá efstu brún
apps/erpnext/erpnext/stock/get_item_details.py +297,Price List {0} is disabled or does not exist,Verðlisti {0} er óvirk eða er ekki til
DocType: Purchase Invoice,Return,Return
DocType: Production Order Operation,Production Order Operation,Framleiðsla Order Operation
DocType: Pricing Rule,Disable,Slökkva
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +153,Mode of payment is required to make a payment,Háttur af greiðslu er krafist til að greiða
DocType: Project Task,Pending Review,Bíður Review
apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +110,"Asset {0} cannot be scrapped, as it is already {1}","Eignastýring {0} er ekki hægt að rífa, eins og það er nú þegar {1}"
DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Krafa (með kostnað kröfu)
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py +70,Customer Id,Auðkenni viðskiptavinar
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Absent
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +133,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Row {0}: Gjaldmiðill af BOM # {1} ætti að vera jafn völdu gjaldmiðil {2}
DocType: Journal Entry Account,Exchange Rate,Exchange Rate
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +555,Sales Order {0} is not submitted,Velta Order {0} er ekki lögð
DocType: Homepage,Tag Line,tag Line
DocType: Fee Component,Fee Component,Fee Component
apps/erpnext/erpnext/config/hr.py +195,Fleet Management,Lo Stjórn
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +894,Add items from,Bæta atriði úr
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +101,Warehouse {0}: Parent account {1} does not bolong to the company {2},Warehouse {0}: Foreldri reikningur {1} er ekki BOLONG fyrirtækinu {2}
DocType: Cheque Print Template,Regular,Venjulegur
apps/erpnext/erpnext/schools/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Alls weightage allra Námsmat Criteria verður að vera 100%
DocType: BOM,Last Purchase Rate,Síðasta Kaup Rate
DocType: Account,Asset,Asset
DocType: Project Task,Task ID,verkefni ID
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Stock getur ekki til fyrir lið {0} síðan hefur afbrigði
,Sales Person-wise Transaction Summary,Sala Person-vitur Transaction Samantekt
DocType: Training Event,Contact Number,Númer tengiliðs
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +144,Warehouse {0} does not exist,Warehouse {0} er ekki til
apps/erpnext/erpnext/hub_node/page/hub/register_in_hub.html +2,Register For ERPNext Hub,Register Fyrir ERPNext Hub
DocType: Monthly Distribution,Monthly Distribution Percentages,Mánaðarleg Dreifing Prósentur
apps/erpnext/erpnext/stock/doctype/batch/batch.py +37,The selected item cannot have Batch,Valið atriði getur ekki Hópur
apps/erpnext/erpnext/stock/stock_ledger.py +456,"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","Verðmat hlutfall fannst ekki í lið {0}, sem er nauðsynlegt til að gera bókhald færslur fyrir {1} {2}. Ef hluturinn er transacting sem sýnishorn hlut í {1}, skaltu nefna að í {1} Liður borð. Annars skaltu búa mótteknu lager viðskipti fyrir hlutinn eða nefna verðmats hraða í Item met, og þá reyna submiting / hætta við þessa færslu"
DocType: Delivery Note,% of materials delivered against this Delivery Note,% Af efnum afhent gegn þessum Delivery Note
DocType: Project,Customer Details,Nánar viðskiptavina
DocType: Employee,Reports to,skýrslur til
,Unpaid Expense Claim,Ógreitt Expense Krafa
DocType: SMS Settings,Enter url parameter for receiver nos,Sláðu url breytu til móttakara Nos
DocType: Payment Entry,Paid Amount,greiddur Upphæð
DocType: Assessment Plan,Supervisor,Umsjón
apps/erpnext/erpnext/accounts/page/pos/pos.js +694,Online,Online
,Available Stock for Packing Items,Laus Stock fyrir pökkun atriði
DocType: Item Variant,Item Variant,Liður Variant
DocType: Assessment Result Tool,Assessment Result Tool,Mat Niðurstaða Tool
DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
apps/erpnext/erpnext/accounts/page/pos/pos.js +855,Submitted orders can not be deleted,Lagðar pantanir ekki hægt að eyða
apps/erpnext/erpnext/accounts/doctype/account/account.py +118,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Viðskiptajöfnuður þegar í Debit, þú ert ekki leyft að setja &#39;Balance Verður Be&#39; eins og &#39;Credit &quot;"
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +80,Quality Management,Gæðastjórnun
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +41,Item {0} has been disabled,Liður {0} hefur verið gerð óvirk
DocType: Employee Loan,Repay Fixed Amount per Period,Endurgreiða Föst upphæð á hvern Tímabil
apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Vinsamlegast sláðu inn magn fyrir lið {0}
DocType: Employee External Work History,Employee External Work History,Starfsmaður Ytri Vinna Saga
DocType: Tax Rule,Purchase,kaup
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Balance Qty,Balance Magn
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Markmið má ekki vera autt
DocType: Item Group,Parent Item Group,Parent Item Group
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} fyrir {1}
apps/erpnext/erpnext/setup/doctype/company/company.js +23,Cost Centers,stoðsviða
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Gengi sem birgis mynt er breytt í grunngj.miðil félagsins
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Row # {0}: tímasetning átök með röð {1}
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Leyfa núgildandi verðmæti
DocType: Training Event Employee,Invited,boðið
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +172,Multiple active Salary Structures found for employee {0} for the given dates,Margar virk launakerfum fundust fyrir starfsmann {0} fyrir gefnar dagsetningar
DocType: Opportunity,Next Contact,næsta samband við
apps/erpnext/erpnext/config/accounts.py +277,Setup Gateway accounts.,Skipulag Gateway reikninga.
DocType: Employee,Employment Type,Atvinna Type
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +40,Fixed Assets,Fastafjármunir
DocType: Payment Entry,Set Exchange Gain / Loss,Setja gengishagnaður / tap
,Cash Flow,Peningaflæði
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Umsókn tímabil getur ekki verið á tveimur alocation færslur
DocType: Item Group,Default Expense Account,Sjálfgefið kostnað reiknings
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +51,Student Email ID,Student Email ID
DocType: Employee,Notice (days),Tilkynning (dagar)
DocType: Tax Rule,Sales Tax Template,Söluskattur Snið
apps/erpnext/erpnext/accounts/page/pos/pos.js +2334,Select items to save the invoice,Veldu atriði til að bjarga reikning
DocType: Employee,Encashment Date,Encashment Dagsetning
DocType: Training Event,Internet,internet
DocType: Account,Stock Adjustment,Stock Leiðrétting
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Sjálfgefið Activity Kostnaður er fyrir hendi Activity Tegund - {0}
DocType: Production Order,Planned Operating Cost,Áætlaðir rekstrarkostnaður
DocType: Academic Term,Term Start Date,Term Start Date
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Upp Count
apps/erpnext/erpnext/controllers/recurring_document.py +136,Please find attached {0} #{1},Meðfylgjandi {0} # {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Bankayfirlit jafnvægi eins og á General Ledger
DocType: Job Applicant,Applicant Name,umsækjandi Nafn
DocType: Authorization Rule,Customer / Item Name,Viðskiptavinur / Item Name
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","Samanlagðar hópur ** Items ** í annað ** Item **. Þetta er gagnlegt ef þú ert að samtvinnun ákveðnum ** Hlutir ** í pakka og þú halda lager af pakkað ** Items ** og ekki samanlagt ** Item **. The pakki ** Item ** mun hafa &quot;Er Stock Item&quot; sem &quot;Nei&quot; og &quot;Er Velta Item&quot; sem &quot;Já&quot;. Til dæmis: ef þú ert að selja Fartölvur og bakpoka sig og hafa sérstakt verð ef viðskiptavinur kaupir bæði, þá Laptop + Bakpoki verður ný vara Knippi Item. Ath: BOM = Bill of Materials"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},Serial Nei er nauðsynlegur fyrir lið {0}
DocType: Item Variant Attribute,Attribute,eiginleiki
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Vinsamlegast tilgreinið frá / til svið
DocType: Serial No,Under AMC,undir AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +54,Item valuation rate is recalculated considering landed cost voucher amount,Liður verðmat hlutfall er endurreiknuð miðað lenti kostnaður úttektarmiðans upphæð
apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Sjálfgefnar stillingar fyrir að selja viðskiptum.
DocType: Guardian,Guardian Of ,Guardian Of
DocType: Grading Scale Interval,Threshold,þröskuldur
DocType: BOM Replace Tool,Current BOM,Núverandi BOM
apps/erpnext/erpnext/public/js/utils.js +39,Add Serial No,Bæta Serial Nei
apps/erpnext/erpnext/config/support.py +22,Warranty,Ábyrgð í
DocType: Purchase Invoice,Debit Note Issued,Debet Note Útgefið
DocType: Production Order,Warehouses,Vöruhús
apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} eign er ekki hægt að flytja
apps/erpnext/erpnext/stock/doctype/item/item.js +66,This Item is a Variant of {0} (Template).,Þetta atriði er afbrigði af {0} (sniðmát).
DocType: Workstation,per hour,á klukkustund
apps/erpnext/erpnext/config/buying.py +7,Purchasing,Innkaupastjóri
DocType: Announcement,Announcement,Tilkynning
DocType: Warehouse,Account for the warehouse (Perpetual Inventory) will be created under this Account.,Reikningur fyrir vöruhús (Perpetual Inventory) verður búin undir þessum reikningi.
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +123,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Warehouse ekki hægt að eyða eins birgðir höfuðbók færsla er til fyrir þetta vöruhús.
DocType: Company,Distribution,Dreifing
apps/erpnext/erpnext/schools/doctype/fees/fees.js +27,Amount Paid,Greidd upphæð
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +95,Project Manager,Verkefnastjóri
,Quoted Item Comparison,Vitnað Item Samanburður
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +76,Dispatch,Sending
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +73,Max discount allowed for item: {0} is {1}%,Max afsláttur leyfð lið: {0} er {1}%
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Net Asset value as on,Innra virði og á
DocType: Account,Receivable,viðskiptakröfur
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +278,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Ekki leyfilegt að breyta birgi Purchase Order er þegar til
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Hlutverk sem er leyft að leggja viðskiptum sem fara lánamörk sett.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +901,Select Items to Manufacture,Veldu Hlutir til Manufacture
apps/erpnext/erpnext/accounts/page/pos/pos.js +919,"Master data syncing, it might take some time","Master gögn syncing, gæti það tekið smá tíma"
DocType: Item,Material Issue,efni Issue
DocType: Hub Settings,Seller Description,Seljandi Lýsing
DocType: Employee Education,Qualification,HM
DocType: Item Price,Item Price,Item verð
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +48,Soap & Detergent,Sápa &amp; Þvottaefni
DocType: BOM,Show Items,Sýna Items
apps/erpnext/erpnext/schools/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,Frá tími getur ekki verið meiri en tíma.
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +36,Motion Picture & Video,Motion Picture &amp; Video
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Pantaði
DocType: Salary Detail,Component,Component
DocType: Assessment Criteria,Assessment Criteria Group,Námsmat Viðmið Group
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Opnun uppsöfnuðum afskriftum verður að vera minna en eða jafnt og {0}
DocType: Warehouse,Warehouse Name,Warehouse Name
DocType: Naming Series,Select Transaction,Veldu Transaction
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Vinsamlegast sláðu inn Samþykkir hlutverki eða samþykkir notandi
DocType: Journal Entry,Write Off Entry,Skrifaðu Off færslu
DocType: BOM,Rate Of Materials Based On,Hlutfall af efni byggt á
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Stuðningur Analtyics
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +142,Uncheck all,Afhakaðu allt
apps/erpnext/erpnext/accounts/doctype/accounts_settings/accounts_settings.py +28,Company is missing in warehouses {0},Félagið vantar í vöruhús {0}
DocType: POS Profile,Terms and Conditions,Skilmálar og skilyrði
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},Til Dagsetning ætti að vera innan fjárhagsársins. Að því gefnu að Dagsetning = {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Hér er hægt að halda hæð, þyngd, ofnæmi, læknis áhyggjum etc"
DocType: Leave Block List,Applies to Company,Gildir til félagsins
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,Cannot cancel because submitted Stock Entry {0} exists,Ekki er hægt að hætta við vegna þess að lögð Stock Entry {0} hendi
DocType: Employee Loan,Disbursement Date,útgreiðsludagur
DocType: Vehicle,Vehicle,ökutæki
DocType: Purchase Invoice,In Words,í orðum
DocType: POS Profile,Item Groups,Item Hópar
apps/erpnext/erpnext/hr/doctype/employee/employee.py +217,Today is {0}'s birthday!,Í dag er {0} &#39;s afmæli!
DocType: Production Planning Tool,Material Request For Warehouse,Efni Beiðni um Warehouse
DocType: Sales Order Item,For Production,fyrir framleiðslu
DocType: Payment Request,payment_url,payment_url
DocType: Project Task,View Task,view Task
apps/erpnext/erpnext/public/js/setup_wizard.js +61,Your financial year begins on,Fjárhagsár þinn byrjar á
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Upp / Leið%
DocType: Material Request,MREQ-,MREQ-
,Asset Depreciations and Balances,Eignastýring Afskriftir og jafnvægi
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +329,Amount {0} {1} transferred from {2} to {3},Upphæð {0} {1} flutt frá {2} til {3}
DocType: Sales Invoice,Get Advances Received,Fá Framfarir móttekin
DocType: Email Digest,Add/Remove Recipients,Bæta við / fjarlægja viðtakendur
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +460,Transaction not allowed against stopped Production Order {0},Transaction ekki leyft móti hætt framleiðslu Order {0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Til að stilla þessa rekstrarárs sem sjálfgefið, smelltu á &#39;Setja sem sjálfgefið&#39;"
apps/erpnext/erpnext/projects/doctype/project/project.py +192,Join,Join
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,skortur Magn
apps/erpnext/erpnext/stock/doctype/item/item.py +654,Item variant {0} exists with same attributes,Liður afbrigði {0} hendi með sömu eiginleika
DocType: Employee Loan,Repay from Salary,Endurgreiða frá Laun
DocType: Leave Application,LAP/,LAP /
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +339,Requesting payment against {0} {1} for amount {2},Biðum greiðslu gegn {0} {1} fyrir upphæð {2}
DocType: Salary Slip,Salary Slip,laun Slip
DocType: Lead,Lost Quotation,Lost Tilvitnun
DocType: Pricing Rule,Margin Rate or Amount,Framlegð hlutfall eða upphæð
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,&quot;Til Dagsetning &#39;er krafist
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Mynda pökkun laumar fyrir pakka til að vera frelsari. Notað til að tilkynna pakka númer, Innihald pakkningar og þyngd sína."
DocType: Sales Invoice Item,Sales Order Item,Velta Order Item
DocType: Salary Slip,Payment Days,Greiðsla Days
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +221,Warehouses with child nodes cannot be converted to ledger,Vöruhús með hnúta barn er ekki hægt að breyta í höfuðbók
DocType: BOM,Manage cost of operations,Stjórna kostnaði við rekstur
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.","Þegar einhverju merkt viðskipti eru &quot;Lögð&quot;, tölvupóst pop-upp sjálfkrafa opnað að senda tölvupóst til tilheyrandi &quot;Contact&quot; í því viðskiptum, við viðskiptin sem viðhengi. Notandinn mega eða mega ekki senda tölvupóst."
apps/erpnext/erpnext/config/setup.py +14,Global Settings,Global Settings
DocType: Assessment Result Detail,Assessment Result Detail,Mat Niðurstaða Detail
DocType: Employee Education,Employee Education,starfsmaður Menntun
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,Duplicate item group found in the item group table,Afrit atriði hópur í lið töflunni
apps/erpnext/erpnext/public/js/controllers/transaction.js +986,It is needed to fetch Item Details.,Það er nauðsynlegt að ná Item upplýsingar.
DocType: Salary Slip,Net Pay,Net Borga
DocType: Account,Account,Reikningur
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} has already been received,Serial Nei {0} hefur þegar borist
,Requested Items To Be Transferred,Umbeðin Items til að flytja
DocType: Expense Claim,Vehicle Log,ökutæki Log
apps/erpnext/erpnext/controllers/stock_controller.py +91,"Warehouse {0} is not linked to any account, please create/link the corresponding (Asset) account for the warehouse.",Warehouse {0} er ekki tengd við hvaða reikning skaltu búa / tengja samsvarandi (eign) reikningur fyrir lager.
DocType: Purchase Invoice,Recurring Id,Fastir Id
DocType: Customer,Sales Team Details,Upplýsingar Söluteymi
apps/erpnext/erpnext/accounts/page/pos/pos.js +1288,Delete permanently?,Eyða varanlega?
DocType: Expense Claim,Total Claimed Amount,Alls tilkalli Upphæð
apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Hugsanleg tækifæri til að selja.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +228,Invalid {0},Ógild {0}
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +52,Sick Leave,Veikindaleyfi
DocType: Email Digest,Email Digest,Tölvupóstur Digest
DocType: Delivery Note,Billing Address Name,Billing Address Nafn
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +22,Department Stores,Department Stores
DocType: Warehouse,PIN,PIN
apps/erpnext/erpnext/setup/setup_wizard/sample_data.py +108,Setup your School in ERPNext,Skipulag School þín í ERPNext
DocType: Sales Invoice,Base Change Amount (Company Currency),Base Breyta Upphæð (Company Gjaldmiðill)
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +308,No accounting entries for the following warehouses,Engar bókhald færslur fyrir eftirfarandi vöruhús
apps/erpnext/erpnext/projects/doctype/project/project.js +92,Save the document first.,Vistaðu skjalið fyrst.
DocType: Account,Chargeable,ákæru
DocType: Company,Change Abbreviation,Breyta Skammstöfun
DocType: Expense Claim Detail,Expense Date,Expense Dagsetning
DocType: Item,Max Discount (%),Max Afsláttur (%)
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Síðasta Order Magn
DocType: Task,Is Milestone,Er Milestone
DocType: Daily Work Summary,Email Sent To,Tölvupóstur sendur til
DocType: Budget,Warn,Warn
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Allar aðrar athugasemdir, athyglisvert áreynsla sem ætti að fara í skrám."
DocType: BOM,Manufacturing User,framleiðsla User
DocType: Purchase Invoice,Raw Materials Supplied,Raw Materials Staðar
DocType: Purchase Invoice,Recurring Print Format,Fastir Prenta Format
DocType: C-Form,Series,Series
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +61,Expected Delivery Date cannot be before Purchase Order Date,Áætlaðan fæðingardag getur ekki verið áður Kaup Order Dagsetning
DocType: Appraisal,Appraisal Template,Úttekt Snið
DocType: Item Group,Item Classification,Liður Flokkun
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +93,Business Development Manager,Business Development Manager
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Viðhald Visit Tilgangur
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +16,Period,tímabil
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,General Ledger
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Starfsmaður {0} á skilið á {1}
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Skoða Vísbendingar
DocType: Program Enrollment Tool,New Program,ný Program
DocType: Item Attribute Value,Attribute Value,eigindi gildi
,Itemwise Recommended Reorder Level,Itemwise Mælt Uppröðun Level
DocType: Salary Detail,Salary Detail,laun Detail
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +962,Please select {0} first,Vinsamlegast veldu {0} fyrst
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +795,Batch {0} of Item {1} has expired.,Hópur {0} af Liður {1} hefur runnið út.
DocType: Sales Invoice,Commission,þóknun
apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Tími Sheet fyrir framleiðslu.
apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Samtals
DocType: Salary Detail,Default Amount,Sjálfgefið Upphæð
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +93,Warehouse not found in the system,Warehouse fannst ekki í kerfinu
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,This Month's Summary,Samantekt þessa mánaðar
DocType: Quality Inspection Reading,Quality Inspection Reading,Quality Inspection Reading
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +24,`Freeze Stocks Older Than` should be smaller than %d days.,`Freeze Stocks Eldri Than` ætti að vera minni en% d daga.
DocType: Tax Rule,Purchase Tax Template,Kaup Tax sniðmáti
,Project wise Stock Tracking,Project vitur Stock mælingar
DocType: Stock Entry Detail,Actual Qty (at source/target),Raunveruleg Magn (á uppspretta / miða)
DocType: Item Customer Detail,Ref Code,Ref Code
apps/erpnext/erpnext/config/hr.py +12,Employee records.,Employee færslur.
apps/erpnext/erpnext/accounts/doctype/asset/asset.py +92,Please set Next Depreciation Date,Vinsamlegast settu Next Afskriftir Dagsetning
DocType: HR Settings,Payroll Settings,launaskrá Stillingar
apps/erpnext/erpnext/config/accounts.py +148,Match non-linked Invoices and Payments.,Passa non-tengd og greiðslur.
apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Panta
DocType: Email Digest,New Purchase Orders,Ný Purchase Pantanir
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Rót getur ekki hafa foreldri kostnaður miðstöð
apps/erpnext/erpnext/public/js/stock_analytics.js +58,Select Brand...,Veldu Brand ...
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Accumulated Depreciation as on,Uppsöfnuðum afskriftum og á
DocType: Sales Invoice,C-Form Applicable,C-Form Gildir
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +398,Operation Time must be greater than 0 for Operation {0},Operation Time verður að vera hærri en 0 fyrir notkun {0}
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +105,Warehouse is mandatory,Warehouse er nauðsynlegur
DocType: Supplier,Address and Contacts,Heimilisfang og Tengiliðir
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM viðskipta Detail
apps/erpnext/erpnext/public/js/setup_wizard.js +172,Keep it web friendly 900px (w) by 100px (h),Keep It vefur vingjarnlegur 900px (w) af 100px (H)
DocType: Program,Program Abbreviation,program Skammstöfun
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +386,Production Order cannot be raised against a Item Template,Framleiðsla Order er ekki hægt að hækka gegn Item sniðmáti
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +51,Charges are updated in Purchase Receipt against each item,Gjöld eru uppfærðar á kvittun við hvert atriði
DocType: Warranty Claim,Resolved By,leyst með
DocType: Bank Guarantee,Start Date,Upphafsdagur
apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Úthluta lauf um tíma.
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Tékkar og Innlán rangt hreinsaðar
apps/erpnext/erpnext/accounts/doctype/account/account.py +51,Account {0}: You can not assign itself as parent account,Reikningur {0}: Þú getur ekki framselt sig sem foreldri reikning
DocType: Purchase Invoice Item,Price List Rate,Verðskrá Rate
apps/erpnext/erpnext/utilities/activation.py +70,Create customer quotes,Búa viðskiptavina tilvitnanir
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Sýna &quot;Á lager&quot; eða &quot;ekki til á lager&quot; byggist á lager í boði í þessum vöruhúsi.
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,Meðaltal tíma tekin af birgi að skila
apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.js +11,Assessment Result,mat Niðurstaða
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,klukkustundir
DocType: Project,Expected Start Date,Væntanlegur Start Date
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +48,Remove item if charges is not applicable to that item,Fjarlægja hlut ef gjöld eru ekki við þann lið
DocType: SMS Settings,Eg. smsgateway.com/api/send_sms.cgi,Td. smsgateway.com/api/send_sms.cgi
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +33,Transaction currency must be same as Payment Gateway currency,Transaction gjaldmiðli skal vera það sama og Greiðsla Gateway gjaldmiðil
DocType: Payment Entry,Receive,fá
apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Tilvitnun:
DocType: Maintenance Visit,Fully Completed,fullu lokið
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Complete
DocType: Employee,Educational Qualification,námsgráðu
DocType: Workstation,Operating Costs,því að rekstrarkostnaðurinn
DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Aðgerð ef Uppsafnaður mánuðinn Budget meiri en
DocType: Purchase Invoice,Submit on creation,Senda á sköpun
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +442,Currency for {0} must be {1},Gjaldeyri fyrir {0} verður að vera {1}
DocType: Asset,Disposal Date,förgun Dagsetning
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.","Póstur verður sendur á öllum virkum Starfsmenn félagsins á tilteknu klukkustund, ef þeir hafa ekki frí. Samantekt á svörum verður sent á miðnætti."
DocType: Employee Leave Approver,Employee Leave Approver,Starfsmaður Leave samþykkjari
apps/erpnext/erpnext/stock/doctype/item/item.py +499,Row {0}: An Reorder entry already exists for this warehouse {1},Row {0}: An Uppröðun færslu þegar til fyrir þessa vöruhús {1}
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +82,"Cannot declare as lost, because Quotation has been made.","Get ekki lýst því sem glatast, af því Tilvitnun hefur verið gert."
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +13,Training Feedback,Þjálfun Feedback
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +457,Production Order {0} must be submitted,Framleiðslu Order {0} Leggja skal fram
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +150,Please select Start Date and End Date for Item {0},Vinsamlegast veldu Ræsa og lokadag fyrir lið {0}
apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +54,Course is mandatory in row {0},Auðvitað er skylda í röð {0}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,Hingað til er ekki hægt að áður frá dagsetningu
DocType: Supplier Quotation Item,Prevdoc DocType,Prevdoc DOCTYPE
apps/erpnext/erpnext/stock/doctype/item/item.js +250,Add / Edit Prices,Bæta við / Breyta Verð
DocType: Batch,Parent Batch,Foreldri hópur
DocType: Cheque Print Template,Cheque Print Template,Ávísun Prenta Snið
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Mynd af stoðsviða
,Requested Items To Be Ordered,Umbeðin Items til að panta
apps/erpnext/erpnext/accounts/doctype/account/account.py +181,Warehouse company must be same as Account company,Warehouse fyrirtækið verður að vera það sama og reiknings félagsins
DocType: Price List,Price List Name,Verðskrá Name
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +31,Daily Work Summary for {0},Daily Work Yfirlit fyrir {0}
DocType: Employee Loan,Totals,Samtölur
DocType: BOM,Manufacturing,framleiðsla
,Ordered Items To Be Delivered,Pantaði Items til afhendingar
DocType: Account,Income,tekjur
DocType: Industry Type,Industry Type,Iðnaður Type
apps/erpnext/erpnext/templates/includes/cart.js +149,Something went wrong!,Eitthvað fór úrskeiðis!
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +124,Warning: Leave application contains following block dates,Viðvörun: Leyfi umsókn inniheldur eftirfarandi block dagsetningar
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +263,Sales Invoice {0} has already been submitted,Velta Invoice {0} hefur þegar verið lögð
DocType: Assessment Result Detail,Score,Mark
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Reikningsár {0} er ekki til
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Verklok
DocType: Purchase Invoice Item,Amount (Company Currency),Upphæð (Company Gjaldmiðill)
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} einingar {1} þörf {2} á {3} {4} fyrir {5} að ljúka þessari færslu.
DocType: Fee Structure,Student Category,Student Flokkur
DocType: Announcement,Student,Student
apps/erpnext/erpnext/config/hr.py +229,Organization unit (department) master.,Organization eining (umdæmi) skipstjóri.
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +26,Please enter valid mobile nos,Vinsamlegast sláðu inn gilt farsímanúmer Nos
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Vinsamlegast sláðu inn skilaboð áður en þú sendir
DocType: Email Digest,Pending Quotations,Bíður Tilvitnun
apps/erpnext/erpnext/config/accounts.py +282,Point-of-Sale Profile,Point-af-sölu Profile
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +75,Please Update SMS Settings,Uppfærðu SMS Settings
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Unsecured Loans,Ótryggð Lán
DocType: Cost Center,Cost Center Name,Kostnaður Center Name
DocType: Employee,B+,B +
DocType: HR Settings,Max working hours against Timesheet,Max vinnutíma gegn Timesheet
DocType: Maintenance Schedule Detail,Scheduled Date,áætlunarferðir Dagsetning
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +69,Total Paid Amt,Alls Greiddur Amt
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Skilaboð meiri en 160 stafir verður skipt í marga skilaboð
DocType: Purchase Receipt Item,Received and Accepted,Móttekið og samþykkt
,Serial No Service Contract Expiry,Serial Nei Service Contract gildir til
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Þú getur ekki kredit-og debetkort sama reikning á sama tíma
DocType: Naming Series,Help HTML,Hjálp HTML
DocType: Student Group Creation Tool,Student Group Creation Tool,Student Group Creation Tool
DocType: Item,Variant Based On,Variant miðað við
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Alls weightage úthlutað ætti að vera 100%. Það er {0}
apps/erpnext/erpnext/public/js/setup_wizard.js +265,Your Suppliers,Birgjar þín
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +58,Cannot set as Lost as Sales Order is made.,Get ekki stillt eins Lost og Sales Order er gert.
DocType: Request for Quotation Item,Supplier Part No,Birgir Part No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +356,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Get ekki draga þegar flokkur er fyrir &#39;Verðmat&#39; eða &#39;Vaulation og heildar&#39;
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +336,Received From,fékk frá
DocType: Lead,Converted,converted
DocType: Item,Has Serial No,Hefur Serial Nei
DocType: Employee,Date of Issue,Útgáfudagur
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +19,{0}: From {0} for {1},{0}: Frá {0} fyrir {1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +157,Row #{0}: Set Supplier for item {1},Row # {0}: Setja Birgir fyrir lið {1}
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Hours value must be greater than zero.,Row {0}: Hours verður að vera stærri en núll.
apps/erpnext/erpnext/stock/doctype/item/item.py +173,Website Image {0} attached to Item {1} cannot be found,Vefsíða Image {0} fylgir tl {1} er ekki hægt að finna
DocType: Issue,Content Type,content Type
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,tölva
DocType: Item,List this Item in multiple groups on the website.,Listi þetta atriði í mörgum hópum á vefnum.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,Vinsamlegast athugaðu Multi Currency kost að leyfa reikninga með öðrum gjaldmiðli
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +86,Item: {0} does not exist in the system,Item: {0} er ekki til í kerfinu
apps/erpnext/erpnext/accounts/doctype/account/account.py +110,You are not authorized to set Frozen value,Þú hefur ekki heimild til að setja Frozen gildi
DocType: Payment Reconciliation,Get Unreconciled Entries,Fá Unreconciled færslur
DocType: Payment Reconciliation,From Invoice Date,Frá dagsetningu reiknings
apps/erpnext/erpnext/accounts/party.py +250,Billing currency must be equal to either default comapany's currency or party account currency,Innheimta gjaldmiðli skal vera jöfn gjaldmiðil eða aðili reikning gjaldmiðli hvoru vanræksla Comapany er
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +37,Leave Encashment,Skildu Encashment
apps/erpnext/erpnext/public/js/setup_wizard.js +48,What does it do?,Hvað gerir það?
apps/erpnext/erpnext/stock/doctype/batch/batch.js +70,To Warehouse,til Warehouse
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +23,All Student Admissions,Allir Student Innlagnir
,Average Commission Rate,Meðal framkvæmdastjórnarinnar Rate
apps/erpnext/erpnext/stock/doctype/item/item.py +411,'Has Serial No' can not be 'Yes' for non-stock item,&quot;Hefur Serial Nei &#39;getur ekki verið&#39; Já &#39;fyrir non-lager lið
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,Aðsókn er ekki hægt að merkja fyrir framtíð dagsetningar
DocType: Pricing Rule,Pricing Rule Help,Verðlagning Regla Hjálp
DocType: School House,House Name,House Name
DocType: Purchase Taxes and Charges,Account Head,Head Reikningur
apps/erpnext/erpnext/config/stock.py +168,Update additional costs to calculate landed cost of items,Uppfærðu aukakostnað að reikna lenti kostnað af hlutum
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +115,Electrical,Electrical
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,Bætið restinni af fyrirtækinu þínu sem notendur. Þú getur einnig bætt við boðið viðskiptavinum sínum að vefsíðunni þinni með því að bæta þeim við úr Tengiliðum
DocType: Stock Entry,Total Value Difference (Out - In),Heildarverðmæti Mismunur (Out - In)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Row {0}: Exchange Rate er nauðsynlegur
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},User ID ekki sett fyrir Starfsmaður {0}
DocType: Vehicle,Vehicle Value,ökutæki Value
DocType: Stock Entry,Default Source Warehouse,Sjálfgefið Source Warehouse
DocType: Item,Customer Code,viðskiptavinur Code
apps/erpnext/erpnext/hr/doctype/employee/employee.py +216,Birthday Reminder for {0},Afmæli Áminning fyrir {0}
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Dagar frá síðustu Order
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +336,Debit To account must be a Balance Sheet account,Debit Til reikning verður að vera Efnahagur reikning
DocType: Buying Settings,Naming Series,nafngiftir Series
DocType: Leave Block List,Leave Block List Name,Skildu Block List Nafn
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Tryggingar Start dagsetning ætti að vera minna en tryggingar lokadagsetning
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,lager Eignir
DocType: Timesheet,Production Detail,framleiðsla Detail
DocType: Target Detail,Target Qty,Target Magn
DocType: Shopping Cart Settings,Checkout Settings,Checkout Stillingar
DocType: Attendance,Present,Present
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +35,Delivery Note {0} must not be submitted,Afhending Note {0} Ekki má leggja
DocType: Notification Control,Sales Invoice Message,Velta Invoice Message
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Lokun reikning {0} verður að vera af gerðinni ábyrgðar / Equity
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +320,Salary Slip of employee {0} already created for time sheet {1},Laun Slip starfsmanns {0} þegar búið fyrir tíma blaði {1}
DocType: Vehicle Log,Odometer,kílómetramæli
DocType: Sales Order Item,Ordered Qty,Raðaður Magn
apps/erpnext/erpnext/stock/doctype/item/item.py +682,Item {0} is disabled,Liður {0} er óvirk
DocType: Stock Settings,Stock Frozen Upto,Stock Frozen uppí
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +879,BOM does not contain any stock item,BOM inniheldur ekki lager atriði
apps/erpnext/erpnext/controllers/recurring_document.py +172,Period From and Period To dates mandatory for recurring {0},Tímabil Frá og tímabil Til dagsetningar lögboðnum fyrir endurteknar {0}
apps/erpnext/erpnext/config/projects.py +18,Project activity / task.,Project virkni / verkefni.
DocType: Vehicle Log,Refuelling Details,Eldsneytisstöðvar Upplýsingar
apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Búa Laun laumar
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +44,"Buying must be checked, if Applicable For is selected as {0}","Kaup verður að vera merkt, ef við á er valið sem {0}"
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,Afsláttur verður að vera minna en 100
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +108,Last purchase rate not found,Síðustu kaup hlutfall fannst ekki
DocType: Purchase Invoice,Write Off Amount (Company Currency),Skrifaðu Off Upphæð (Company Gjaldmiðill)
DocType: Sales Invoice Timesheet,Billing Hours,Billing Hours
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +499,Default BOM for {0} not found,Sjálfgefið BOM fyrir {0} fannst ekki
apps/erpnext/erpnext/stock/doctype/item/item.py +491,Row #{0}: Please set reorder quantity,Row # {0}: Vinsamlegast settu pöntunarmark magn
apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Pikkaðu á atriði til að bæta þeim við hér
DocType: Fees,Program Enrollment,program Innritun
DocType: Landed Cost Voucher,Landed Cost Voucher,Landað Kostnaður Voucher
apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Vinsamlegast settu {0}
DocType: Purchase Invoice,Repeat on Day of Month,Endurtakið á degi mánaðarins
apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +39,{0} - {1} is inactive student,{0} - {1} er óvirkur nemandi
DocType: Employee,Health Details,Heilsa Upplýsingar
DocType: Offer Letter,Offer Letter Terms,Tilboð bréf Skilmálar
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +23,To create a Payment Request reference document is required,Til að búa til greiðslubeiðni þarf viðmiðunarskjal
DocType: Payment Entry,Allocate Payment Amount,Úthluta Greiðsla Upphæð
DocType: Employee External Work History,Salary,Laun
DocType: Serial No,Delivery Document Type,Afhending Document Type
DocType: Process Payroll,Submit all salary slips for the above selected criteria,Senda öll laun laumar fyrir ofan valin forsendum
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +93,{0} Items synced,{0} Items samstillt
DocType: Sales Order,Partly Delivered,hluta Skilað
DocType: Email Digest,Receivables,Viðskiptakröfur
DocType: Lead Source,Lead Source,Lead Source
DocType: Customer,Additional information regarding the customer.,Viðbótarupplýsingar um viðskiptavininn.
DocType: Quality Inspection Reading,Reading 5,lestur 5
DocType: Maintenance Visit,Maintenance Date,viðhald Dagsetning
DocType: Purchase Invoice Item,Rejected Serial No,Hafnað Serial Nei
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,Ár Upphafsdagur eða lokadagsetning er skörun við {0}. Til að forðast skaltu stilla fyrirtæki
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +157,Start date should be less than end date for Item {0},Upphafsdagur ætti að vera minna en lokadagsetningu fyrir lið {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.","Dæmi:. ABCD ##### Ef röð er sett og Serial Nei er ekki getið í viðskiptum, þá sjálfvirkur raðnúmer verður búin byggt á þessari röð. Ef þú vilt alltaf að beinlínis sé minnst Serial Nos fyrir þetta atriði. autt."
DocType: Upload Attendance,Upload Attendance,Hlaða Aðsókn
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +306,BOM and Manufacturing Quantity are required,BOM og framleiðsla Magn þarf
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Ageing Range 2
DocType: SG Creation Tool Course,Max Strength,max Strength
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +21,BOM replaced,BOM stað
,Sales Analytics,velta Analytics
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +114,Available {0},Laus {0}
,Prospects Engaged But Not Converted,Horfur Engaged en ekki umbreytt
DocType: Manufacturing Settings,Manufacturing Settings,framleiðsla Stillingar
apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Setja upp tölvupóst
apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Mobile No,Guardian1 Mobile No
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +98,Please enter default currency in Company Master,Vinsamlegast sláðu inn sjálfgefið mynt í félaginu Master
DocType: Stock Entry Detail,Stock Entry Detail,Stock Entry Detail
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Daily Reminders,Daglegar áminningar
DocType: Products Settings,Home Page is Products,Home Page er vörur
,Asset Depreciation Ledger,Asset Afskriftir Ledger
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +86,Tax Rule Conflicts with {0},Tax regla Árekstrar með {0}
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Nýtt nafn Account
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Raw Materials Staðar Kostnaður
DocType: Selling Settings,Settings for Selling Module,Stillingar fyrir Selja Module
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +77,Customer Service,Þjónustuver
DocType: BOM,Thumbnail,Smámynd
DocType: Item Customer Detail,Item Customer Detail,Liður Viðskiptavinur Detail
apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Tilboð frambjóðandi a Job.
DocType: Notification Control,Prompt for Email on Submission of,Hvetja til Email um Framlagning
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Samtals úthlutað Blöðin eru fleiri en dagar á tímabilinu
DocType: Pricing Rule,Percentage,hlutfall
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,Liður {0} verður að vera birgðir Item
DocType: Manufacturing Settings,Default Work In Progress Warehouse,Sjálfgefið Work In Progress Warehouse
apps/erpnext/erpnext/config/accounts.py +257,Default settings for accounting transactions.,Sjálfgefnar stillingar fyrir bókhald viðskiptum.
DocType: Maintenance Visit,MV,MV
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +59,Expected Date cannot be before Material Request Date,Væntanlegur Dagsetning má ekki vera áður Material Beiðni Dagsetning
DocType: Purchase Invoice Item,Stock Qty,Fjöldi hluta
DocType: Production Order,Source Warehouse (for reserving Items),Heimild Warehouse (fyrir áskilið Atriði)
DocType: Employee Loan,Repayment Period in Months,Lánstími í mánuði
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Villa: Ekki gild id?
DocType: Naming Series,Update Series Number,Uppfæra Series Number
DocType: Account,Equity,Eigið fé
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}: &#39;Rekstrarreikningur &quot;tegund reiknings {2} ekki leyfð í Opnun Entry
DocType: Sales Order,Printing Details,Prentun Upplýsingar
DocType: Task,Closing Date,lokadegi
DocType: Sales Order Item,Produced Quantity,framleidd Magn
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Engineer,verkfræðingur
DocType: Journal Entry,Total Amount Currency,Heildarfjárhæð Gjaldmiðill
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Leit Sub þing
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Item Code required at Row No {0},Item Code þörf á Row nr {0}
DocType: Sales Partner,Partner Type,Gerð Partner
DocType: Purchase Taxes and Charges,Actual,Raunveruleg
DocType: Authorization Rule,Customerwise Discount,Customerwise Afsláttur
apps/erpnext/erpnext/config/projects.py +35,Timesheet for tasks.,Timesheet fyrir verkefni.
DocType: Purchase Invoice,Against Expense Account,Against kostnað reikning
DocType: Production Order,Production Order,framleiðsla Order
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +270,Installation Note {0} has already been submitted,Uppsetning Ath {0} hefur þegar verið lögð fram
DocType: Bank Reconciliation,Get Payment Entries,Fá greiðslu færslur
DocType: Quotation Item,Against Docname,Against DOCNAME
DocType: SMS Center,All Employee (Active),Allt Starfsmaður (Active)
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,skoða Now
DocType: Purchase Invoice,Select the period when the invoice will be generated automatically,Veldu tímabil þegar reikningurinn verður sjálfkrafa
DocType: BOM,Raw Material Cost,Raw Material Kostnaður
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.,Sláðu atriði og fyrirhugað Magn sem þú vilt að hækka framleiðslu pantanir eða sækja hráefni til greiningar.
apps/erpnext/erpnext/projects/doctype/project/project.js +45,Gantt Chart,Gantt Mynd
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +61,Part-time,Hluta
DocType: Employee,Applicable Holiday List,Gildandi Holiday List
DocType: Employee,Cheque,ávísun
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +61,Series Updated,Series Uppfært
apps/erpnext/erpnext/accounts/doctype/account/account.py +163,Report Type is mandatory,Tegund skýrslu er nauðsynlegur
DocType: Item,Serial Number Series,Serial Number Series
apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},Warehouse er nauðsynlegur fyrir hlutabréfum lið {0} í röð {1}
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +45,Retail & Wholesale,Retail &amp; Heildverslun
DocType: Issue,First Responded On,Fyrst svöruðu
DocType: Website Item Group,Cross Listing of Item in multiple groups,Cross Skráning Liður í mörgum hópum
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},Reikningsár Start Date og Fiscal Year End Date eru nú þegar sett í Fiscal Year {0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Úthreinsun Date uppfært
apps/erpnext/erpnext/stock/doctype/batch/batch.js +126,Split Batch,Skipta lotu
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,tókst Samræmd
DocType: Request for Quotation Supplier,Download PDF,Sækja PDF
DocType: Production Order,Planned End Date,Áætlaðir Lokadagur
apps/erpnext/erpnext/config/stock.py +184,Where items are stored.,Hvar hlutir eru geymdar.
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +52,Supplier &gt; Supplier Type,Birgir&gt; Birgir Tegund
DocType: Request for Quotation,Supplier Detail,birgir Detail
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +95,Error in formula or condition: {0},Villa í formúlu eða ástandi: {0}
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +22,Invoiced Amount,Upphæð á reikningi
DocType: Attendance,Attendance,Aðsókn
apps/erpnext/erpnext/public/js/pos/pos.html +106,Stock Items,lager vörur
DocType: BOM,Materials,efni
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.",Ef ekki hakað listi verður að vera bætt við hvorri deild þar sem það þarf að vera beitt.
apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Uppruni og Target Warehouse getur ekki verið það sama
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +534,Posting date and posting time is mandatory,Staða dagsetningu og staða tími er nauðsynlegur
apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Tax sniðmát fyrir að kaupa viðskiptum.
,Item Prices,Item Verð
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,Í orðum verður sýnileg þegar þú hefur vistað Purchase Order.
DocType: Period Closing Voucher,Period Closing Voucher,Tímabil Lokar Voucher
apps/erpnext/erpnext/config/selling.py +67,Price List master.,Verðskrá húsbóndi.
DocType: Task,Review Date,Review Date
DocType: Purchase Invoice,Advance Payments,fyrirframgreiðslur
DocType: Purchase Taxes and Charges,On Net Total,Á Nettó
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},Gildi fyrir eigind {0} verður að vera innan þeirra marka sem {1} til {2} í þrepum {3} fyrir lið {4}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +160,Target warehouse in row {0} must be same as Production Order,Target vöruhús í röð {0} verður að vera það sama og framleiðslu Order
apps/erpnext/erpnext/controllers/recurring_document.py +217,'Notification Email Addresses' not specified for recurring %s,&quot;tilkynning netföng &#39;ekki tilgreint fyrir endurteknar% s
apps/erpnext/erpnext/accounts/doctype/account/account.py +128,Currency can not be changed after making entries using some other currency,Gjaldmiðill er ekki hægt að breyta eftir að færslur með einhverja aðra mynt
DocType: Vehicle Service,Clutch Plate,Clutch Plate
DocType: Company,Round Off Account,Umferð Off reikning
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +91,Administrative Expenses,rekstrarkostnaður
apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,ráðgjöf
DocType: Customer Group,Parent Customer Group,Parent Group Viðskiptavinur
DocType: Purchase Invoice,Contact Email,Netfang tengiliðar
DocType: Appraisal Goal,Score Earned,skora aflað
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +191,Notice Period,uppsagnarfrestur
DocType: Asset Category,Asset Category Name,Asset Flokkur Nafn
apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Þetta er rót landsvæði og ekki hægt að breyta.
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Nýtt Sales Person Name
DocType: Packing Slip,Gross Weight UOM,Gross Weight UOM
DocType: Delivery Note Item,Against Sales Invoice,Against sölureikningi
DocType: Bin,Reserved Qty for Production,Frátekið Magn fyrir framleiðslu
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Leyfi óskráð ef þú vilt ekki íhuga hópur meðan þú setur námskeið.
DocType: Asset,Frequency of Depreciation (Months),Tíðni Afskriftir (mánuðir)
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +468,Credit Account,Credit Reikningur
DocType: Landed Cost Item,Landed Cost Item,Landað kostnaðarliðurinn
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Sýna núll gildi
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Magn lið sem fæst eftir framleiðslu / endurpökkunarinnar úr gefin magni af hráefni
apps/erpnext/erpnext/public/js/setup_wizard.js +320,Setup a simple website for my organization,Skipulag einföld vefsíða fyrir fyrirtæki mitt
DocType: Payment Reconciliation,Receivable / Payable Account,/ Viðskiptakröfur Account
DocType: Delivery Note Item,Against Sales Order Item,Gegn Sales Order Item
apps/erpnext/erpnext/stock/doctype/item/item.py +649,Please specify Attribute Value for attribute {0},Vinsamlegast tilgreindu Attribute virði fyrir eigind {0}
DocType: Item,Default Warehouse,Sjálfgefið Warehouse
apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Fjárhagsáætlun er ekki hægt að úthlutað gegn Group reikninginn {0}
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,Vinsamlegast sláðu foreldri kostnaðarstað
DocType: Delivery Note,Print Without Amount,Prenta Án Upphæð
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,Afskriftir Dagsetning
apps/erpnext/erpnext/controllers/buying_controller.py +79,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,Tax Category getur ekki verið &#39;Verðmat&#39; eða &#39;og þeim Samtals&#39; sem allir hlutir eru ekki birgðir atriði
DocType: Issue,Support Team,Stuðningur Team
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Fyrning (í dögum)
DocType: Appraisal,Total Score (Out of 5),Total Score (af 5)
DocType: Fee Structure,FS.,FS.
DocType: Program Enrollment,Batch,hópur
apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Balance
DocType: Room,Seating Capacity,sætafjölda
DocType: Issue,ISS-,Út-
DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Krafa (með kostnað kröfum)
DocType: Assessment Result,Total Score,Total Score
DocType: Journal Entry,Debit Note,debet Note
DocType: Stock Entry,As per Stock UOM,Eins og á lager UOM
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,ekki Útrunnið
DocType: Student Log,Achievement,Achievement
DocType: Batch,Source Document Type,Heimild skjal tegund
DocType: Journal Entry,Total Debit,alls skuldfærsla
DocType: Manufacturing Settings,Default Finished Goods Warehouse,Sjálfgefin fullunnum Warehouse
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +78,Sales Person,Sölufulltrúa
DocType: SMS Parameter,SMS Parameter,SMS Parameter
apps/erpnext/erpnext/config/accounts.py +202,Budget and Cost Center,Fjárhagsáætlun og kostnaður Center
DocType: Vehicle Service,Half Yearly,Half Árlega
DocType: Lead,Blog Subscriber,Blog Notandanúmer
DocType: Guardian,Alternate Number,varamaður Number
DocType: Assessment Plan Criteria,Maximum Score,Hámarks Einkunn
apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Búa til reglur til að takmarka viðskipti sem byggjast á gildum.
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Skildu eftir ef þú gerir nemendur hópa á ári
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Ef hakað Total nr. vinnudaga mun fela frí, og þetta mun draga úr gildi af launum fyrir dag"
DocType: Purchase Invoice,Total Advance,alls 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.,Hugtakið Lokadagur getur ekki verið fyrr en Term Start Date. Vinsamlega leiðréttu dagsetningar og reyndu aftur.
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Tilvitnun
,BOM Stock Report,BOM Stock Report
DocType: Stock Reconciliation Item,Quantity Difference,magn Mismunur
apps/erpnext/erpnext/config/hr.py +311,Processing Payroll,Vinnsla Launaskrá
DocType: Opportunity Item,Basic Rate,Basic Rate
DocType: GL Entry,Credit Amount,Credit Upphæð
DocType: Cheque Print Template,Signatory Position,Undirritaður Staða
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +178,Set as Lost,Setja sem Lost
DocType: Timesheet,Total Billable Hours,Samtals vinnustunda
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Greiðslukvittun Note
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Þetta er byggt á viðskiptum móti þessum viðskiptavinar. Sjá tímalínu hér fyrir nánari upplýsingar
DocType: Supplier,Credit Days Based On,Credit Days Byggt á
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},Row {0}: Reiknaðar upphæð {1} verður að vera minna en eða jafngildir Greiðsla Entry upphæð {2}
DocType: Tax Rule,Tax Rule,Tax Regla
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Halda Sama hlutfall á öllu söluferlið
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Skipuleggja tíma logs utan Workstation vinnutíma.
apps/erpnext/erpnext/public/js/pos/pos.html +89,Customers in Queue,Viðskiptavinir í biðröð
DocType: Student,Nationality,Þjóðerni
,Items To Be Requested,Hlutir til að biðja
DocType: Purchase Order,Get Last Purchase Rate,Fá Síðasta kaupgengi
DocType: Company,Company Info,Upplýsingar um fyrirtæki
apps/erpnext/erpnext/accounts/page/pos/pos.js +1320,Select or add new customer,Veldu eða bæta við nýjum viðskiptavin
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +146,Cost center is required to book an expense claim,Kostnaður sent er nauðsynlegt að bóka kostnað kröfu
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Umsókn um Funds (eignum)
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Þetta er byggt á mætingu þessa starfsmanns
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +462,Debit Account,skuldfærslureikning
DocType: Fiscal Year,Year Start Date,Ár Start Date
DocType: Attendance,Employee Name,starfsmaður Name
DocType: Sales Invoice,Rounded Total (Company Currency),Ávalur Total (Company Gjaldmiðill)
apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Cannot covert to Group because Account Type is selected.,Get ekki leynilegar að samstæðunnar vegna Tegund reiknings er valinn.
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +231,{0} {1} has been modified. Please refresh.,{0} {1} hefur verið breytt. Vinsamlegast hressa.
DocType: Leave Block List,Stop users from making Leave Applications on following days.,Hættu notendur frá gerð yfirgefa Umsóknir um næstu dögum.
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,kaup Upphæð
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +212,Supplier Quotation {0} created,Birgir Tilvitnun {0} búin
apps/erpnext/erpnext/accounts/report/financial_statements.py +97,End Year cannot be before Start Year,Árslok getur ekki verið áður Start Ár
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +184,Employee Benefits,starfskjör
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +252,Packed quantity must equal quantity for Item {0} in row {1},Pakkað magn verður að vera jafnt magn fyrir lið {0} í röð {1}
DocType: Production Order,Manufactured Qty,Framleiðandi Magn
DocType: Purchase Receipt Item,Accepted Quantity,Samþykkt Magn
apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Please set a default Holiday List for Employee {0} or Company {1},Vinsamlegast setja sjálfgefið Holiday lista fyrir Starfsmaður {0} eða fyrirtækis {1}
apps/erpnext/erpnext/accounts/party.py +28,{0}: {1} does not exists,{0}: {1} er ekki til
apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Víxlar vakti til viðskiptavina.
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Project Id
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},Row Engin {0}: Upphæð má ekki vera meiri en Bíður Upphæð á móti kostnað {1} kröfu. Bið Upphæð er {2}
DocType: Maintenance Schedule,Schedule,Dagskrá
DocType: Account,Parent Account,Parent Reikningur
DocType: Quality Inspection Reading,Reading 3,lestur 3
,Hub,Hub
DocType: GL Entry,Voucher Type,skírteini Type
apps/erpnext/erpnext/accounts/page/pos/pos.js +1596,Price List not found or disabled,Verðlisti fannst ekki eða fatlaður
DocType: Employee Loan Application,Approved,samþykkt
DocType: Pricing Rule,Price,verð
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +261,Employee relieved on {0} must be set as 'Left',Starfsmaður létta á {0} skal stilla eins &#39;Vinstri&#39;
DocType: Guardian,Guardian,Guardian
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Úttekt {0} búin til starfsmanns {1} á tilteknu tímabili
DocType: Employee,Education,menntun
apps/erpnext/erpnext/public/js/pos/pos.html +80,Del,Del
DocType: Selling Settings,Campaign Naming By,Herferð Nafngift By
DocType: Employee,Current Address Is,Núverandi Heimilisfang er
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,Breytt
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +51,"Optional. Sets company's default currency, if not specified.","Valfrjálst. Leikmynd sjálfgefið mynt félagsins, ef ekki tilgreint."
apps/erpnext/erpnext/config/accounts.py +61,Accounting journal entries.,Bókhald dagbók færslur.
DocType: Delivery Note Item,Available Qty at From Warehouse,Laus Magn á frá vöruhúsi
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,Vinsamlegast veldu Starfsmaður Taka fyrst.
DocType: POS Profile,Account for Change Amount,Reikningur fyrir Change Upphæð
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Row {0}: Party / Account passar ekki við {1} / {2} í {3} {4}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +238,Please enter Expense Account,Vinsamlegast sláðu inn kostnað reikning
DocType: Account,Stock,Stock
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +985,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Tilvísun Document Type verður að vera einn af Purchase Order, Purchase Invoice eða Journal Entry"
DocType: Employee,Current Address,Núverandi heimilisfang
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","Ef hluturinn er afbrigði af annað lið þá lýsingu, mynd, verðlagningu, skatta osfrv sett verður úr sniðmátinu nema skýrt tilgreint"
DocType: Serial No,Purchase / Manufacture Details,Kaup / Framleiðsla Upplýsingar
DocType: Assessment Group,Assessment Group,mat Group
apps/erpnext/erpnext/config/stock.py +320,Batch Inventory,hópur Inventory
DocType: Employee,Contract End Date,Samningur Lokadagur
DocType: Sales Order,Track this Sales Order against any Project,Fylgjast með þessari sölu til gegn hvers Project
DocType: Sales Invoice Item,Discount and Margin,Afsláttur og Framlegð
DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,Draga velta pantanir (bið að skila) miðað við ofangreindar viðmiðanir
DocType: Pricing Rule,Min Qty,min Magn
DocType: Asset Movement,Transaction Date,Færsla Dagsetning
DocType: Production Plan Item,Planned Qty,Planned Magn
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +104,Total Tax,Total Tax
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +176,For Quantity (Manufactured Qty) is mandatory,Fyrir Magn (Framleiðandi Magn) er nauðsynlegur
DocType: Stock Entry,Default Target Warehouse,Sjálfgefið Target Warehouse
DocType: Purchase Invoice,Net Total (Company Currency),Net Total (Company Gjaldmiðill)
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.,The Year End Date getur ekki verið fyrr en árið Start Date. Vinsamlega leiðréttu dagsetningar og reyndu aftur.
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Row {0}: Party Gerð og Party gildir aðeins gegn / viðskiptakröfur reikning
DocType: Notification Control,Purchase Receipt Message,Kvittun Skilaboð
DocType: BOM,Scrap Items,Rusl Items
DocType: Production Order,Actual Start Date,Raunbyrjunardagsetning
DocType: Sales Order,% of materials delivered against this Sales Order,% Af efnum afhent gegn þessum Sales Order
apps/erpnext/erpnext/config/stock.py +12,Record item movement.,Upptaka atriði hreyfing.
DocType: Training Event Employee,Withdrawn,hætt við
DocType: Hub Settings,Hub Settings,Hub Stillingar
DocType: Project,Gross Margin %,Heildarframlegð %
DocType: BOM,With Operations,með starfsemi
apps/erpnext/erpnext/accounts/party.py +246,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Bókhald færslur hafa verið gerðar í gjaldmiðli {0} fyrir fyrirtæki {1}. Vinsamlegast veldu nái eða greiða ber reikning með gjaldeyri {0}.
DocType: Asset,Is Existing Asset,Er núverandi eign
DocType: Salary Detail,Statistical Component,Tölfræðilegur hluti
,Monthly Salary Register,Mánaðarlaunum Register
DocType: Warranty Claim,If different than customer address,Ef öðruvísi en viðskiptavinur heimilisfangi
DocType: BOM Operation,BOM Operation,BOM Operation
DocType: School Settings,Validate the Student Group from Program Enrollment,Staðfesta nemendahópinn frá verkefnaskráningu
DocType: Purchase Taxes and Charges,On Previous Row Amount,Á fyrri röð Upphæð
DocType: Student,Home Address,Heimilisfangið
apps/erpnext/erpnext/accounts/doctype/asset/asset.js +260,Transfer Asset,Transfer Asset
DocType: POS Profile,POS Profile,POS Profile
DocType: Training Event,Event Name,Event Name
apps/erpnext/erpnext/config/schools.py +39,Admission,Aðgangseyrir
apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +26,Admissions for {0},Innlagnir fyrir {0}
apps/erpnext/erpnext/config/accounts.py +226,"Seasonality for setting budgets, targets etc.","Árstíðum til að setja fjárveitingar, markmið o.fl."
apps/erpnext/erpnext/stock/get_item_details.py +137,"Item {0} is a template, please select one of its variants",Liður {0} er sniðmát skaltu velja einn af afbrigði hennar
DocType: Asset,Asset Category,Asset Flokkur
apps/erpnext/erpnext/public/js/setup_wizard.js +207,Purchaser,kaupanda
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +30,Net pay cannot be negative,Net borga ekki vera neikvæð
DocType: SMS Settings,Static Parameters,Static Parameters
DocType: Assessment Plan,Room,Room
DocType: Purchase Order,Advance Paid,Advance Greiddur
DocType: Item,Item Tax,Liður Tax
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +798,Material to Supplier,Efni til Birgir
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +366,Excise Invoice,vörugjöld Invoice
apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}% virðist oftar en einu sinni
DocType: Expense Claim,Employees Email Id,Starfsmenn Netfang Id
DocType: Employee Attendance Tool,Marked Attendance,Marked Aðsókn
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +136,Current Liabilities,núverandi Skuldir
apps/erpnext/erpnext/config/selling.py +292,Send mass SMS to your contacts,Senda massa SMS til þinn snerting
DocType: Program,Program Name,program Name
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Íhuga skatta og álaga fyrir
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Raunveruleg Magn er nauðsynlegur
DocType: Employee Loan,Loan Type,lán Type
DocType: Scheduling Tool,Scheduling Tool,Tímasetningar Tool
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +142,Credit Card,Kreditkort
DocType: BOM,Item to be manufactured or repacked,Liður í að framleiða eða repacked
apps/erpnext/erpnext/config/stock.py +179,Default settings for stock transactions.,Sjálfgefnar stillingar fyrir lager viðskipta.
DocType: Purchase Invoice,Next Date,næsta Dagsetning
DocType: Employee Education,Major/Optional Subjects,Major / valgreinum
DocType: Sales Invoice Item,Drop Ship,Drop Ship
DocType: Training Event,Attendees,Fundarmenn
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Hér er hægt að halda upplýsingar fjölskyldu eins og nafn og starfsheiti foreldri, maka og börn"
DocType: Academic Term,Term End Date,Term Lokadagur
DocType: Hub Settings,Seller Name,Seljandi Name
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Skattar og gjöld FrÃ¡ (Company Gjaldmiðill)
DocType: Item Group,General Settings,Almennar stillingar
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,Frá Gjaldmiðill og gjaldmiðla getur ekki verið það sama
DocType: Stock Entry,Repack,gera við
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Þú verður að vista eyðublaðið áður en lengra er haldið
DocType: Item Attribute,Numeric Values,talnagildi
apps/erpnext/erpnext/public/js/setup_wizard.js +177,Attach Logo,hengja Logo
apps/erpnext/erpnext/stock/doctype/batch/batch.js +38,Stock Levels,lager Levels
DocType: Customer,Commission Rate,Framkvæmdastjórnin Rate
apps/erpnext/erpnext/stock/doctype/item/item.js +324,Make Variant,gera Variant
apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Block orlofsrétt umsóknir deild.
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +125,"Payment Type must be one of Receive, Pay and Internal Transfer","Greiðsla Type verður að vera einn af fáum, Borga og Innri Transfer"
apps/erpnext/erpnext/config/selling.py +179,Analytics,Analytics
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +21,Cart is Empty,Karfan er tóm
DocType: Vehicle,Model,Model
DocType: Production Order,Actual Operating Cost,Raunveruleg rekstrarkostnaður
DocType: Payment Entry,Cheque/Reference No,Ávísun / tilvísunarnúmer
apps/erpnext/erpnext/accounts/doctype/account/account.py +85,Root cannot be edited.,Root ekki hægt að breyta.
DocType: Item,Units of Measure,Mælieiningar
DocType: Manufacturing Settings,Allow Production on Holidays,Leyfa Framleiðsla á helgidögum
DocType: Sales Order,Customer's Purchase Order Date,Viðskiptavinar Purchase Order Date
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +161,Capital Stock,Capital Stock
DocType: Shopping Cart Settings,Show Public Attachments,Sýna opinberar viðhengi
DocType: Packing Slip,Package Weight Details,Pakki Þyngd Upplýsingar
DocType: Payment Gateway Account,Payment Gateway Account,Greiðsla Gateway Reikningur
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,Að lokinni greiðslu áframsenda notandann til valda síðu.
DocType: Company,Existing Company,núverandi Company
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Vinsamlegast veldu csv skrá
DocType: Student Leave Application,Mark as Present,Merkja sem Present
DocType: Purchase Order,To Receive and Bill,Að taka við og Bill
apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Valin Vörur
apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +98,Designer,hönnuður
apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Skilmálar og skilyrði Snið
DocType: Serial No,Delivery Details,Afhending Upplýsingar
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +483,Cost Center is required in row {0} in Taxes table for type {1},Kostnaður Center er krafist í röð {0} skatta borð fyrir tegund {1}
DocType: Program,Program Code,program Code
DocType: Terms and Conditions,Terms and Conditions Help,Skilmálar og skilyrði Hjálp
,Item-wise Purchase Register,Item-vitur Purchase Register
DocType: Batch,Expiry Date,Fyrningardagsetning
,Supplier Addresses and Contacts,Birgir Heimilisföng og Tengiliðir
,accounts-browser,reikningar-vafra
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +342,Please select Category first,Vinsamlegast veldu Flokkur fyrst
apps/erpnext/erpnext/config/projects.py +13,Project master.,Project húsbóndi.
apps/erpnext/erpnext/controllers/status_updater.py +198,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Til að leyfa yfir innheimtu eða yfir-röðun, uppfæra &quot;vasapeninga&quot; í lager Stillingar eða hlutinn."
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,Ekki sýna tákn eins og $ etc hliðina gjaldmiðlum.
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +459, (Half Day),(Hálfur dagur)
DocType: Supplier,Credit Days,Credit Days
apps/erpnext/erpnext/utilities/activation.py +126,Make Student Batch,Gera Student Hópur
DocType: Leave Type,Is Carry Forward,Er bera fram
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +778,Get Items from BOM,Fá atriði úr BOM
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Lead Time Days
apps/erpnext/erpnext/controllers/accounts_controller.py +566,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Row # {0}: Staða Dagsetning skal vera það sama og kaupdegi {1} eignar {2}
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +129,Please enter Sales Orders in the above table,Vinsamlegast sláðu sölu skipunum í töflunni hér að ofan
apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +186,Not Submitted Salary Slips,Ekki lögð Laun laumar
,Stock Summary,Stock Yfirlit
apps/erpnext/erpnext/config/accounts.py +241,Transfer an asset from one warehouse to another,Flytja eign frá einu vöruhúsi til annars
DocType: Vehicle,Petrol,Bensín
apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Bill of Materials
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +103,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Party Gerð og Party er nauðsynlegt fyrir / viðskiptakröfur reikninginn {1}
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref Dagsetning
DocType: Employee,Reason for Leaving,Ástæða til að fara
DocType: BOM Operation,Operating Cost(Company Currency),Rekstrarkostnaður (Company Gjaldmiðill)
DocType: Employee Loan Application,Rate of Interest,Vöxtum
DocType: Expense Claim Detail,Sanctioned Amount,bundnar Upphæð
DocType: GL Entry,Is Opening,er Opnun
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Row {0}: gjaldfærslu ekki hægt að tengja með {1}
apps/erpnext/erpnext/accounts/doctype/account/account.py +234,Account {0} does not exist,Reikningur {0} er ekki til
DocType: Account,Cash,Cash
DocType: Employee,Short biography for website and other publications.,Stutt ævisaga um vefsíðu og öðrum ritum.
