diff --git a/erpnext/translations/is.csv b/erpnext/translations/is.csv
index c9ce6f4..0ecf180 100644
--- a/erpnext/translations/is.csv
+++ b/erpnext/translations/is.csv
@@ -1,8 +1,8 @@
 DocType: Employee,Salary Mode,laun Mode
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +67,Register,Nýskráning
 DocType: Patient,Divorced,skilin
 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/config/education.py +118,Assessment Reports,Matsskýrslur
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Consumer Products
 DocType: Purchase Receipt,Subscription Detail,Áskriftarupplýsingar
 DocType: Supplier Scorecard,Notify Supplier,Tilkynna birgir
@@ -20,9 +20,9 @@
 DocType: Restaurant Order Entry,Click Enter To Add,Smelltu á Enter til að bæta við
 DocType: Employee,Rented,leigt
 DocType: Purchase Order,PO-,PO-
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +216,"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"
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +225,"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/assets/doctype/asset/asset.js +240,Do you really want to scrap this asset?,Viltu virkilega að skrappa þessa eign?
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +253,Do you really want to scrap this asset?,Viltu virkilega að skrappa þessa eign?
 DocType: Drug Prescription,Update Schedule,Uppfæra áætlun
 apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,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}
@@ -48,16 +48,17 @@
 DocType: Leave Type,Leave Type Name,Skildu Tegund Nafn
 apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,sýna opinn
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Nauðsynlegt er að taka þessa aðgerð í dag sjálft fyrir ofangreindum endurteknum
+apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +24,Diagnosis and Complaints cannot be left blank,Greining og kvörtun má ekki vera autt
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Series Uppfært Tókst
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Athuga
+apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Athuga
 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
-apps/erpnext/erpnext/projects/doctype/project/project.py +72,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 +115,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
+apps/erpnext/erpnext/projects/doctype/project/project.py +74,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 +117,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 +241,New Leave Application,Ný Leave Umsókn
 ,Batch Item Expiry Status,Hópur Item Fyrning Staða
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Bank Draft
 DocType: Membership,membership validaty section,aðildarvottorðsþáttur
@@ -70,7 +71,7 @@
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,efni
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Gerð vefsíða
 DocType: Opening Invoice Creation Tool Item,Quantity,magn
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +544,Accounts table cannot be blank.,Reikninga borð getur ekki verið autt.
+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 +154,Loans (Liabilities),Lán (skulda)
 DocType: Employee Education,Year of Passing,Ár Passing
 DocType: Item,Country of Origin,Upprunaland
@@ -78,19 +79,19 @@
 apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,Á lager
 apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Aðal upplýsingar um tengilið
 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
+DocType: Production Order,Production Plan Item,Framleiðsla Plan Item
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},User {0} er þegar úthlutað til starfsmanns {1}
 DocType: Lab Test Groups,Add new line,Bæta við nýjum línu
 apps/erpnext/erpnext/setup/setup_wizard/data/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)
 DocType: Payment Terms Template Detail,Payment Terms Template Detail,Greiðsluskilmálar Sniðmát smáatriði
+DocType: Hotel Room Reservation,Guest Name,Nafn gesta
 DocType: Lab Prescription,Lab Prescription,Lab Prescription
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +185,Sort by Price,Raða eftir Verð
 ,Delay Days,Frestur daga
 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 +886,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 +878,Invoice,reikningur
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +109,Make Retention Stock Entry,Gerðu varðveisluvörslu
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +897,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 +880,Invoice,reikningur
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145,Make Retention Stock Entry,Gerðu varðveisluvörslu
 DocType: Purchase Invoice Item,Item Weight Details,Vara þyngd upplýsingar
 DocType: Asset Maintenance Log,Periodicity,tíðni
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Reikningsár {0} er krafist
@@ -98,16 +99,16 @@
 apps/erpnext/erpnext/setup/setup_wizard/data/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 +223,Row {0}: {1} {2} does not match with {3},Row {0}: {1} {2} passar ekki við {3}
+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 +77,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 +160,Please select Price List,Vinsamlegast veldu verðskrá
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +162,Please select Price List,Vinsamlegast veldu verðskrá
 DocType: Accounts Settings,Currency Exchange Settings,Valmöguleikar
 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/education/report/absent_student_report/absent_student_report.py +13,Please select date,Vinsamlegast veldu dagsetningu
-DocType: Employee,Holiday List,Holiday List
+DocType: Daily Work Summary Group,Holiday List,Holiday List
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,endurskoðandi
 DocType: Hub Settings,Selling Price List,Selja verðskrá
 DocType: Patient,Tobacco Current Use,Núverandi notkun tóbaks
@@ -115,17 +116,17 @@
 DocType: Cost Center,Stock User,Stock User
 DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
 DocType: Company,Phone No,Sími nei
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +237,New {0}: #{1},New {0}: # {1}
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239,New {0}: #{1},New {0}: # {1}
 DocType: Delivery Trip,Initial Email Notification Sent,Upphafleg póstskilaboð send
 ,Sales Partners Commission,Velta Partners Commission
 DocType: Soil Texture,Sandy Clay Loam,Sandy Clay Loam
 DocType: Purchase Invoice,Rounding Adjustment,Afrennslisbreyting
-apps/erpnext/erpnext/setup/doctype/company/company.py +45,Abbreviation cannot have more than 5 characters,Skammstöfun getur ekki haft fleiri en 5 stafi
+apps/erpnext/erpnext/setup/doctype/company/company.py +46,Abbreviation cannot have more than 5 characters,Skammstöfun getur ekki haft fleiri en 5 stafi
 DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Læknisáætlun Stundaskrá
 DocType: Payment Request,Payment Request,greiðsla Beiðni
 DocType: Asset,Value After Depreciation,Gildi Eftir Afskriftir
 DocType: Student,O+,O +
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +18,Related,Tengdar
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,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
 DocType: Subscription,Repeat on Day,Endurtaka á dag
@@ -139,18 +140,18 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Tilvísun: {0}, Liður: {1} og Viðskiptavinur: {2}"
 apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,kg
 apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Opnun fyrir Job.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +110,BOM is not specified for subcontracting item {0} at row {1},BOM er ekki tilgreint fyrir undirverktaka atriði {0} í röð {1}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114,BOM is not specified for subcontracting item {0} at row {1},BOM er ekki tilgreint fyrir undirverktaka atriði {0} í röð {1}
 apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,{0} Niðurstöður sendar inn
 DocType: Item Attribute,Increment,vöxtur
-apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +61,Timespan,Tímabil
+apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,Tímabil
 apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Veldu Warehouse ...
 apps/erpnext/erpnext/setup/setup_wizard/data/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: Patient,Married,giftur
-apps/erpnext/erpnext/accounts/party.py +44,Not permitted for {0},Ekki leyft {0}
+apps/erpnext/erpnext/accounts/party.py +42,Not permitted for {0},Ekki leyft {0}
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Fá atriði úr
 DocType: Price List,Price Not UOM Dependant,Verð ekki UOM háð
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +454,Stock cannot be updated against Delivery Note {0},Stock Ekki er hægt að uppfæra móti afhendingarseðlinum {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +465,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: Asset Repair,Error Description,Villa lýsing
@@ -161,10 +162,10 @@
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +91,Next Depreciation Date cannot be before Purchase Date,Næsta Afskriftir Dagsetning má ekki vera áður kaupdegi
 DocType: Crop,Perennial,Ævarandi
 DocType: Consultation,Consultation Date,Samráðsdagur
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +131,Product listing and discovery for ERPNext users,Vörulisti og uppgötvun fyrir ERPNext notendur
+DocType: Accounts Settings,Use Custom Cash Flow Format,Notaðu Custom Cash Flow Format
 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 +1743,Not items found,Ekki atriði fundust
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1752,Not items found,Ekki atriði fundust
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Laun Uppbygging vantar
 DocType: Lead,Person Name,Sá Name
 DocType: Sales Invoice Item,Sales Invoice Item,Velta Invoice Item
@@ -173,28 +174,26 @@
 apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""",td &quot;Primary School&quot; eða &quot;University&quot;
 apps/erpnext/erpnext/config/stock.py +28,Stock Reports,lager Skýrslur
 DocType: Warehouse,Warehouse Detail,Warehouse Detail
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +193,Credit limit has been crossed for customer {0} {1}/{2},Hámarksupphæð hefur verið yfir fyrir viðskiptavin {0} {1} / {2}
 apps/erpnext/erpnext/education/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 +258,"""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"
+apps/erpnext/erpnext/stock/doctype/item/item.py +268,"""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: Delivery Trip,Departure Time,Brottfaratími
 DocType: Vehicle Service,Brake Oil,Brake Oil
 DocType: Tax Rule,Tax Type,Tax Type
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +568,Taxable Amount,Skattskyld fjárhæð
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +581,Taxable Amount,Skattskyld fjárhæð
 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)
 DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Hour Rate / 60) * Raunveruleg Rekstur Time
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Row # {0}: Tilvísun Document Type verður að vera einn af kostnaðarkröfu eða dagbókarfærslu
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +964,Select BOM,Veldu BOM
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +966,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/config/hr.py +127,Manage advance amount given to the Employee,Stjórna fyrirframupphæð sem gefinn er til starfsmanns
 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
 apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Sniðmát af birgðastöðu.
 DocType: Lead,Interested,áhuga
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +191,Opening,opnun
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +30,From {0} to {1},Frá {0} til {1}
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216,Opening,opnun
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},Frá {0} til {1}
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Mistókst að setja upp skatta
 DocType: Item,Copy From Item Group,Afrita Frá Item Group
 DocType: Delivery Trip,Delivery Notification,Afhending Tilkynning
@@ -207,28 +206,28 @@
 DocType: Education Settings,Validate Batch for Students in Student Group,Staðfestu hópur fyrir nemendur í nemendahópi
 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 +366,Please select Company first,Vinsamlegast veldu Company fyrst
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365,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: Soil Analysis,Ca/K,Ca / K
 DocType: Journal Entry Account,Employee Loan,starfsmaður Lán
 DocType: Fee Schedule,Send Payment Request Email,Sendu inn beiðni um greiðslubeiðni
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +259,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/manufacturing/doctype/bom/bom.py +269,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/data/industry_type.py +44,Real Estate,Fasteign
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Reikningsyfirlit
 apps/erpnext/erpnext/setup/setup_wizard/data/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 +256,"Available qty is {0}, you need {1}","Laus Magn er {0}, þú þarft {1}"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +260,"Available qty is {0}, you need {1}","Laus Magn er {0}, þú þarft {1}"
 DocType: Expense Claim Detail,Claim Amount,bótafjárhæðir
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,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 +31,Supplier Type / Supplier,Birgir Type / Birgir
 DocType: Naming Series,Prefix,forskeyti
 apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Staðsetning viðburðar
+DocType: Asset Settings,Asset Settings,Eignastillingar
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,einnota
 DocType: Student,B-,B-
-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
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +100,Successfully unregistered.,Árangurslaust óskráð.
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98,Successfully unregistered.,Árangurslaust óskráð.
 DocType: Assessment Result,Grade,bekk
 DocType: Restaurant Table,No of Seats,Nei sæti
 DocType: Subscription,"To add dynamic subject, use jinja tags like
@@ -237,19 +236,21 @@
 DocType: Sales Invoice Item,Delivered By Supplier,Samþykkt með Birgir
 DocType: Asset Maintenance Task,Asset Maintenance Task,Viðhaldsverkefni eigna
 DocType: SMS Center,All Contact,Allt samband við
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +952,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/operations/install_fixtures.py +230,Annual Salary,árslaunum
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954,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/operations/install_fixtures.py +231,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 +380,{0} {1} is frozen,{0} {1} er frosinn
-apps/erpnext/erpnext/setup/doctype/company/company.py +136,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/party.py +393,{0} {1} is frozen,{0} {1} er frosinn
+apps/erpnext/erpnext/setup/doctype/company/company.py +140,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 +80,Stock Expenses,lager Útgjöld
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +103,Select Target Warehouse,Veldu Target Warehouse
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,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
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxNum,CompAuxNum
 DocType: Journal Entry,Contra Entry,contra Entry
 DocType: Journal Entry Account,Credit in Company Currency,Credit í félaginu Gjaldmiðill
 DocType: Lab Test UOM,Lab Test UOM,Lab Próf UOM
 DocType: Delivery Note,Installation Status,uppsetning Staða
+DocType: BOM,Quality Inspection Template,Gæðaskoðunar sniðmát
 apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
 					<br>Absent: {1}",Viltu uppfæra mætingu? <br> Present: {0} \ <br> Fjarverandi: {1}
 apps/erpnext/erpnext/controllers/buying_controller.py +344,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}
@@ -258,13 +259,16 @@
 DocType: Agriculture Analysis Criteria,Fertilizer,Áburður
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +150,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
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +512,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/stock/doctype/stock_entry/stock_entry.py +519,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áð
 DocType: Student Admission Program,Minimum Age,Lágmarksaldur
 apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Dæmi: Basic stærðfræði
+DocType: Customer,Primary Address,Aðal heimilisfang
+DocType: Production Plan,Material Request Detail,Efnisbeiðni Detail
 apps/erpnext/erpnext/controllers/accounts_controller.py +793,"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 +223,Settings for HR Module,Stillingar fyrir HR Module
 DocType: SMS Center,SMS Center,SMS Center
 DocType: Sales Invoice,Change Amount,Breyta Upphæð
+DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Stilltu reikningsgildi fyrir B2C. B2CL og B2CS reiknuð út frá þessum reikningsvirði.
 DocType: BOM Update Tool,New BOM,ný BOM
 apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Sýna aðeins POS
 DocType: Driver,Driving License Categories,Ökuskírteini Flokkar
@@ -272,7 +276,7 @@
 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/hr/doctype/job_offer/job_offer.js +17,Make Employee,gera starfsmanni
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Broadcasting
 apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Uppsetningarhamur POS (Online / Offline)
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,framkvæmd
@@ -284,33 +288,38 @@
 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: Drug Prescription,Interval,Interval
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +252,Preference,Forgangur
 DocType: Grant Application,Individual,einstök
 DocType: Academic Term,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: Supplier Scorecard Period,Supplier Scorecard Period,Birgir Tímabil
+DocType: Share Transfer,Share Transfer,Hlutaflutningur
 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.
+DocType: Daily Work Summary,Daily Work Summary Group,Dagleg vinnusamningshópur
 DocType: Physician Schedule,Time Slots,Tími rifa
 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 (%)
 apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Liður sniðmát
 apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Lífefnafræði
-DocType: Offer Letter,Select Terms and Conditions,Valið Skilmálar og skilyrði
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,Out Value,út Value
-DocType: Production Planning Tool,Sales Orders,velta Pantanir
+DocType: Job Offer,Select Terms and Conditions,Valið Skilmálar og skilyrði
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Out Value,út Value
+DocType: Production Plan,Sales Orders,velta Pantanir
 DocType: Purchase Taxes and Charges,Valuation,verðmat
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +380,Set as Default,Setja sem sjálfgefið
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +386,Set as Default,Setja sem sjálfgefið
+DocType: Production Plan,PLN-,PLN-
 ,Purchase Order Trends,Purchase Order Trends
 apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Fara til viðskiptavina
+DocType: Hotel Room Reservation,Late Checkin,Seint innritun
 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 +258,Insufficient Stock,ófullnægjandi Stock
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +262,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
@@ -320,7 +329,8 @@
 DocType: Selling Settings,Default Territory,Sjálfgefið Territory
 apps/erpnext/erpnext/setup/setup_wizard/data/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 +428,Advance amount cannot be greater than {0} {1},Fyrirfram upphæð getur ekki verið meiri en {0} {1}
+apps/erpnext/erpnext/controllers/taxes_and_totals.py +430,Advance amount cannot be greater than {0} {1},Fyrirfram upphæð getur ekki verið meiri en {0} {1}
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalCode,JournalCode
 DocType: Naming Series,Series List for this Transaction,Series List fyrir þessa færslu
 DocType: Company,Enable Perpetual Inventory,Virkja ævarandi birgða
 DocType: Company,Default Payroll Payable Account,Default Launaskrá Greiðist Reikningur
@@ -330,17 +340,16 @@
 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
 DocType: Supplier Scorecard,Criteria Setup,Viðmiðunarskipulag
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,For Warehouse is required before Submit,Fyrir Lager er krafist áður Senda
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +206,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: Codification Table,Medical Code,Læknisbók
-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 +20,Please enter Company,Vinsamlegast sláðu Company
 DocType: Delivery Note Item,Against Sales Invoice Item,Gegn sölureikningi Item
 DocType: Agriculture Analysis Criteria,Linked Doctype,Tengd Doctype
 ,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 +2333,"LocalStorage is full , did not save","LocalStorage er fullt, ekki spara"
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44,Net Cash from Financing,Handbært fé frá fjármögnun
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2359,"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
 DocType: Sales Partner,Partner website,Vefsíða Partner
@@ -352,27 +361,25 @@
 DocType: Land Unit,Land Unit describing various land assets,Landseining sem lýsir ýmsum eignum landsins
 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/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Assessment Plan: ,Námsmat:
 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.
 DocType: Lab Test,Submitted Date,Sendingardagur
 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
 DocType: Payment Term,Credit Months,Lánshæfismat
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409,Net Pay cannot be less than 0,Net Borga má ekki vera minna en 0
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +408,Net Pay cannot be less than 0,Net Borga má ekki vera minna en 0
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription",Til að hætta að senda endurteknar villuboð frá kerfinu höfum við valið fatlaða reit í áskriftinni
-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 +121,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/operations/install_fixtures.py +238,Leaves per Year,Leaves á ári
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +128,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 +216,Warehouse {0} does not belong to company {1},Warehouse {0} ekki tilheyra félaginu {1}
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,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 +219,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/utilities/user_progress.py +144,Litre,Litre
 DocType: Task,Total Costing Amount (via Time Sheet),Total kostnaðarútreikninga Magn (með Time Sheet)
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Vinsamlegast settu upp nemendur undir nemendahópum
 DocType: Item Website Specification,Item Website Specification,Liður Website Specification
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +509,Leave Blocked,Skildu Bannaður
-apps/erpnext/erpnext/stock/doctype/item/item.py +709,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 +99,Bank Entries,Bank Entries
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449,Leave Blocked,Skildu Bannaður
+apps/erpnext/erpnext/stock/doctype/item/item.py +739,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 +83,Bank Entries,Bank Entries
 DocType: Crop,Annual,Árleg
 DocType: Stock Reconciliation Item,Stock Reconciliation Item,Stock Sættir Item
 DocType: Stock Entry,Sales Invoice No,Reiknings No.
@@ -389,11 +396,12 @@
 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 +729,Item {0} is cancelled,Liður {0} er hætt
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +952,Material Request,efni Beiðni
+apps/erpnext/erpnext/stock/doctype/item/item.py +761,Item {0} is cancelled,Liður {0} er hætt
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1055,Material Request,efni Beiðni
 DocType: Bank Reconciliation,Update Clearance Date,Uppfæra Úthreinsun Dagsetning
+,GSTR-2,GSTR-2
 DocType: Item,Purchase Details,kaup Upplýsingar
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +387,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}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +394,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: Salary Slip,Total Principal Amount,Samtals höfuðstóll
 DocType: Student Guardian,Relation,relation
 DocType: Student Guardian,Mother,móðir
@@ -410,12 +418,12 @@
 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.
 DocType: Payment Term,Payment Term Name,Nafn greiðsluheiti
 DocType: Healthcare Settings,Create documents for sample collection,Búðu til skjöl til að safna sýni
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +274,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
+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: Shareholder,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 +163,Please select Charge Type first,Vinsamlegast veldu Charge Tegund fyrst
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138,Please select Charge Type first,Vinsamlegast veldu Charge Tegund fyrst
 DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Þú getur skilgreint öll þau verkefni sem þurfa að fara fram fyrir þessa ræktun hér. Dagurinn er notaður til að nefna þann dag sem verkefnið þarf að fara fram, 1 er fyrsta daginn, osfrv."
 DocType: Student Group Student,Student Group Student,Student Group Student
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,nýjustu
@@ -440,7 +448,7 @@
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} getur ekki verið neikvæð fyrir atriðið {2}
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Rangt lykilorð
 DocType: Item,Variant Of,afbrigði af
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +387,Completed Qty can not be greater than 'Qty to Manufacture',Lokið Magn má ekki vera meiri en &#39;Magn í Manufacture&#39;
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +406,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
 DocType: Physician,Time per Appointment,Tími fyrir hvert skipun
@@ -456,17 +464,17 @@
 apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Þetta byggist á viðskiptum gegn þessu fyrirtæki. Sjá tímalínu fyrir neðan til að fá nánari upplýsingar
 DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Tilkynna með tölvupósti á sköpun sjálfvirka Material Beiðni
 apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Þola
-apps/erpnext/erpnext/config/desktop.py +309,Consultationt,Samráð
+apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},Vinsamlegast settu herbergi fyrir herbergi á {}
 DocType: Journal Entry,Multi Currency,multi Gjaldmiðill
 DocType: Opening Invoice Creation Tool,Invoice Type,Reikningar Type
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +933,Delivery Note,Afhendingarseðilinn
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939,Delivery Note,Afhendingarseðilinn
 DocType: Consultation,Encounter Impression,Fundur birtingar
 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 +134,Cost of Sold Asset,Kostnaðarverð seldrar Eignastýring
 DocType: Volunteer,Morning,Morgunn
 apps/erpnext/erpnext/accounts/utils.py +350,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.
 DocType: Program Enrollment Tool,New Student Batch,Námsmaður Námsmaður
-apps/erpnext/erpnext/stock/doctype/item/item.py +464,{0} entered twice in Item Tax,{0} slá inn tvisvar í lið Tax
+apps/erpnext/erpnext/stock/doctype/item/item.py +478,{0} entered twice in Item Tax,{0} slá inn tvisvar í lið Tax
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,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
@@ -487,22 +495,23 @@
 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 +622,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}
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +255,[Urgent] Error while creating recurring %s for %s,[Urgent] Villa við að búa til endurtekin% s fyrir% s
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257,[Urgent] Error while creating recurring %s for %s,[Urgent] Villa við að búa til endurtekin% s fyrir% s
 DocType: Land Unit,LInked Analysis,Linkað greining
 DocType: Item Tax,Tax Rate,skatthlutfall
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +74,Application period cannot be across two allocation records,Umsóknarfrestur getur ekki verið yfir tveimur úthlutunarskrám
 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 +919,Select Item,Veldu Item
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141,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}
+DocType: Material Request Plan Item,Material Request Plan Item,Efnisyfirlit
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Umbreyta til non-Group
 DocType: C-Form Invoice Detail,Invoice Date,Dagsetning reiknings
 DocType: GL Entry,Debit Amount,debet Upphæð
-apps/erpnext/erpnext/accounts/party.py +251,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 +426,Please see attachment,Vinsamlega sjá viðhengi
+apps/erpnext/erpnext/accounts/party.py +249,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 +425,Please see attachment,Vinsamlega sjá viðhengi
 DocType: Purchase Order,% Received,% móttekin
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Búa Student Hópar
 DocType: Volunteer,Weekends,Helgar
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Credit Note Amount,Lánshæð upphæð
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +105,Credit Note Amount,Lánshæð upphæð
 DocType: Setup Progress Action,Action Document,Aðgerð skjal
 DocType: Chapter Member,Website URL,vefslóð
 ,Finished Goods,fullunnum
@@ -514,10 +523,10 @@
 apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,ERPNext Demo
 apps/erpnext/erpnext/public/js/utils/item_selector.js +20,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
+DocType: Job Offer Term,Job Offer Term,Atvinnutími
 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/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Lögboðið reit - Fá nemendur frá
@@ -530,20 +539,20 @@
 DocType: Request for Quotation,Request for Quotation,Beiðni um tilvitnun
 DocType: Healthcare Settings,Require Lab Test Approval,Krefjast samþykkis Lab Test
 DocType: Salary Slip Timesheet,Working Hours,Vinnutími
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +10,Total Outstanding,Samtals framúrskarandi
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +49,Total Outstanding,Samtals framúrskarandi
 DocType: Naming Series,Change the starting / current sequence number of an existing series.,Breyta upphafsdegi / núverandi raðnúmer núverandi röð.
 DocType: Dosage Strength,Strength,Styrkur
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1524,Create a new Customer,Búa til nýja viðskiptavini
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1533,Create a new Customer,Búa til nýja viðskiptavini
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","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 +90,Create Purchase Orders,Búa innkaupapantana
 ,Purchase Register,kaup Register
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +119,Patient not found,Sjúklingur fannst ekki
 DocType: 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 +177,Reason for losing,Ástæðan fyrir að tapa
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Reason for losing,Ástæðan fyrir að tapa
 apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Uppfæra reikningsnúmer
 apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Lead Eigandi getur ekki verið sama og Lead
 apps/erpnext/erpnext/accounts/utils.py +356,Allocated amount can not greater than unadjusted amount,Úthlutað magn getur ekki hærri en óleiðréttum upphæð
@@ -566,6 +575,7 @@
 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: Purchase Invoice,01-Sales Return,01-Velta aftur
 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
@@ -579,33 +589,33 @@
 DocType: Lead,Channel Partner,Channel Partner
 DocType: Account,Old Parent,Old Parent
 apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Skyldanlegt námskeið - námsár
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} is not associated with {2} {3},{0} {1} tengist ekki {2} {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +215,{0} {1} is not associated with {2} {3},{0} {1} tengist ekki {2} {3}
 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/hr/doctype/expense_claim/expense_claim.py +182,Please set default payable account for the company {0},Vinsamlegast settu sjálfgefinn greiðslureikning fyrir fyrirtækið {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +174,Please set default payable account for the company {0},Vinsamlegast settu sjálfgefinn greiðslureikning fyrir fyrirtækið {0}
 DocType: Setup Progress Action,Min Doc Count,Min Doc Count
 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 +671,Attribute {0} selected multiple times in Attributes Table,Eiginleiki {0} valin mörgum sinnum í eigindum töflu
+apps/erpnext/erpnext/stock/doctype/item/item.py +699,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.
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +77,Opening Invoice Item,Opnun Reikningsatriði
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,Opnun Reikningsatriði
 DocType: Request for Quotation Item,Required Date,Áskilið Dagsetning
 DocType: Delivery Note,Billing Address,Greiðslufang
 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æð
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceRef,PieceRef
 DocType: Request for Quotation,Message for Supplier,Skilaboð til Birgir
 DocType: Driver,DRIVER-.#####,DRIVER -. #####
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Total Magn
+DocType: Sales Invoice,Total Qty,Total Magn
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,Guardian2 Netfang
 DocType: Item,Show in Website (Variant),Sýna í Website (Variant)
 DocType: Employee,Health Concerns,Heilsa Áhyggjuefni
 DocType: Payroll Entry,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
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vinsamlega settu upp starfsmannamiðlunarkerfi í mannauði&gt; HR-stillingar
 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
@@ -619,11 +629,11 @@
 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)
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +129,{0} {1} is cancelled so the action cannot be completed,{0} {1} er lokað þannig að aðgerðin er ekki hægt að ljúka
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132,{0} {1} is cancelled so the action cannot be completed,{0} {1} er lokað þannig að aðgerðin er ekki hægt að ljúka
 DocType: Customer,Buyer of Goods and Services.,Kaupandi vöru og þjónustu.
 DocType: Journal Entry,Accounts Payable,Viðskiptaskuldir
 DocType: Patient,Allergies,Ofnæmi
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +30,The selected BOMs are not for the same item,Völdu BOMs eru ekki fyrir sama hlut
+apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33,The selected BOMs are not for the same item,Völdu BOMs eru ekki fyrir sama hlut
 DocType: Supplier Scorecard Standing,Notify Other,Tilkynna Annað
 DocType: Vital Signs,Blood Pressure (systolic),Blóðþrýstingur (slagbilsþrýstingur)
 DocType: Pricing Rule,Valid Upto,gildir uppí
@@ -634,13 +644,13 @@
 DocType: POS Profile User,POS Profile User,POS prófíl notandi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,bein Tekjur
 DocType: Patient Appointment,Date TIme,Dagsetning Tími
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41,"Can not filter based on Account, if grouped by Account","Getur ekki síað byggð á reikning, ef flokkaðar eftir reikningi"
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,"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/operations/install_fixtures.py +130,Administrative Officer,Administrative Officer
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Uppsetning fyrirtækja og skatta
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Vinsamlegast veldu Námskeið
 DocType: Codification Table,Codification Table,Codification Table
 DocType: Timesheet Detail,Hrs,Hrs
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +350,Please select Company,Vinsamlegast veldu Company
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349,Please select Company,Vinsamlegast veldu Company
 DocType: Stock Entry Detail,Difference Account,munurinn Reikningur
 DocType: Purchase Invoice,Supplier GSTIN,Birgir GSTIN
 apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,Get ekki loka verkefni eins háð verkefni hennar {0} er ekki lokað.
@@ -649,9 +659,10 @@
 DocType: Lab Test Template,Lab Routine,Lab Routine
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,snyrtivörur
 apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Vinsamlegast veldu Lokadagsetning fyrir lokaðan rekstrarskrá
-apps/erpnext/erpnext/stock/doctype/item/item.py +526,"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"
+apps/erpnext/erpnext/stock/doctype/item/item.py +551,"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/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} er ekki til.
 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
@@ -661,13 +672,15 @@
 DocType: Purchase Invoice Item,Item,Item
 apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Hár næmi
 apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Upplýsingar um sjálfboðaliða.
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2513,Serial no item cannot be a fraction,Serial engin lið getur ekki verið brot
+DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Sniðmát fyrir sjóðstreymi
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2539,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/healthcare/doctype/lab_test/lab_test.js +104,"Not permitted, configure Lab Test Template as required","Ekki heimilt, stilla Lab Test Template eftir þörfum"
 DocType: Patient,Risk Factors,Áhættuþættir
 DocType: Patient,Occupational Hazards and Environmental Factors,Starfsáhættu og umhverfisþættir
 DocType: Vital Signs,Respiratory rate,Öndunarhraði
-apps/erpnext/erpnext/config/stock.py +330,Managing Subcontracting,Annast undirverktöku
+apps/erpnext/erpnext/config/stock.py +334,Managing Subcontracting,Annast undirverktöku
 DocType: Vital Signs,Body Temperature,Líkamshiti
 DocType: Project,Project will be accessible on the website to these users,Verkefnið verður aðgengilegur á vef þessara notenda
 DocType: Detected Disease,Disease,Sjúkdómur
@@ -676,8 +689,8 @@
 DocType: Physician,OP Consulting Charge,OP ráðgjöf gjald
 apps/erpnext/erpnext/utilities/user_progress.py +25,Setup your ,Setjið upp
 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 +69,Account {0} does not belong to company: {1},Reikningur {0} ekki tilheyra fyrirtæki: {1}
-apps/erpnext/erpnext/setup/doctype/company/company.py +51,Abbreviation already used for another company,Skammstöfun þegar notuð fyrir annað fyrirtæki
+apps/erpnext/erpnext/setup/doctype/company/company.py +70,Account {0} does not belong to company: {1},Reikningur {0} ekki tilheyra fyrirtæki: {1}
+apps/erpnext/erpnext/setup/doctype/company/company.py +52,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: Asset Repair,ARLOG-,ARLOG-
 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
@@ -685,22 +698,21 @@
 DocType: Crop,Produced Items,Framleiddir hlutir
 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 +351,Reference No and Reference Date is mandatory for Bank transaction,Tilvísun Nei og Frestdagur er nauðsynlegur fyrir banka viðskiptin
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,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: Payment Entry Reference,Supplier Invoice No,Birgir Reikningur nr
 DocType: Territory,For reference,til viðmiðunar
 DocType: Healthcare Settings,Appointment Confirmation,Ráðstefna staðfestingar
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"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 +253,Closing (Cr),Lokun (Cr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256,Closing (Cr),Lokun (Cr)
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Halló
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +110,Move Item,færa Item
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,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 +384,{0} {1} is not active,{0} {1} er ekki virkur
+apps/erpnext/erpnext/accounts/party.py +397,{0} {1} is not active,{0} {1} er ekki virkur
 apps/erpnext/erpnext/config/accounts.py +272,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 +160,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Birgir Warehouse nauðsynlegur fyrir undirverktaka Kvittun
@@ -709,9 +721,9 @@
 DocType: Pricing Rule,Sales Partner,velta Partner
 apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Allir birgir skorar.
 DocType: Buying Settings,Purchase Receipt Required,Kvittun Áskilið
-apps/erpnext/erpnext/stock/doctype/item/item.py +144,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/stock/doctype/item/item.py +154,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 +143,No records found in the Invoice table,Engar færslur finnast í Invoice töflunni
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34,Please select Company and Party Type first,Vinsamlegast veldu Company og Party Gerð fyrst
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Setja sjálfgefið sjálfgefið í pósti prófíl {0} fyrir notanda {1}, vinsamlega slökkt á sjálfgefið"
 apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Financial / bókhald ári.
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Uppsafnaður Gildi
@@ -737,8 +749,10 @@
 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/public/js/utils/item_quick_entry.js +108,Create Variant,Búa til afbrigði
+DocType: Sales Invoice,Shipping Bill Date,Færsla reikningsdagur
+DocType: Production Order,Production Plan,Framleiðsluáætlun
 DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Opna reikningsskilatól
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +851,Sales Return,velta Return
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853,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ð
 ,Total Stock Summary,Samtals yfirlit yfir lager
 DocType: Announcement,Posted By,Posted By
@@ -749,10 +763,11 @@
 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 +225,Opening (Cr),Opening (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +835,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,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/report/trial_balance/trial_balance.py +228,Opening (Cr),Opening (Cr)
+apps/erpnext/erpnext/stock/doctype/item/item.py +871,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 +354,Allocated amount can not be negative,Úthlutað magn getur ekki verið neikvæð
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Vinsamlegast settu fyrirtækið
+DocType: Share Balance,Share Balance,Hlutabréfaviðskipti
 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.
@@ -760,8 +775,9 @@
 DocType: Employee Loan Application,Total Payable Interest,Alls Greiðist Vextir
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Samtals framúrskarandi: {0}
 DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Velta Invoice Timesheet
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +116,Reference No & Reference Date is required for {0},Tilvísunarnúmer &amp; Frestdagur er nauðsynlegt fyrir {0}
+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: Payroll Entry,Select Payment Account to make Bank Entry,Veldu Greiðslureikningur að gera Bank Entry
+DocType: Hotel Settings,Default Invoice Naming Series,Sjálfgefin innheimtuseðill
 apps/erpnext/erpnext/utilities/activation.py +136,"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á"
 DocType: Restaurant Reservation,Restaurant Reservation,Veitingahús pöntun
 DocType: Land Unit,Land Unit Name,Landseiningarheiti
@@ -771,8 +787,7 @@
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Tilkynna viðskiptavinum með tölvupósti
 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: Employee Advance,Claimed Amount,Krafist upphæð
-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/healthcare.py +62,Masters,Masters
+apps/erpnext/erpnext/config/education.py +176,Masters,Masters
 DocType: Assessment Plan,Maximum Assessment Score,Hámarks Mat Einkunn
 apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Update viðskipta banka Dagsetningar
 apps/erpnext/erpnext/config/projects.py +36,Time Tracking,tími mælingar
@@ -806,13 +821,13 @@
 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 +36,"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/accounts/report/cash_flow/cash_flow.py +29,Net Change in Inventory,Net Breyting á Skrá
 apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Starfsmaður Lán Stjórnun
 DocType: Employee,Passport Number,Vegabréfs númer
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Tengsl Guardian2
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,framkvæmdastjóri
 DocType: Payment Entry,Payment From / To,Greiðsla Frá / Til
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +156,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/selling/doctype/customer/customer.py +172,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/accounts/doctype/purchase_invoice/purchase_invoice.py +428,Please set account in Warehouse {0},Vinsamlegast settu inn reikning í vörugeymslu {0}
 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ð
@@ -822,8 +837,9 @@
 DocType: Lab Test Template,Compound,Efnasamband
 DocType: Student Batch Name,Batch Name,hópur Name
 DocType: Fee Validity,Max number of visit,Hámarksfjöldi heimsókna
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +339,Timesheet created:,Timesheet búið:
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913,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}
+,Hotel Room Occupancy,Hótel herbergi umráð
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +358,Timesheet created:,Timesheet búið:
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +924,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/education/doctype/student_applicant/student_applicant.js +24,Enroll,innritast
 DocType: GST Settings,GST Settings,GST Stillingar
 DocType: Selling Settings,Customer Naming By,Viðskiptavinur Nafngift By
@@ -835,21 +851,21 @@
 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: Company,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/data/industry_type.py +43,Publishing,Publishing
+DocType: Accounts Settings,Report Settings,Skýrslu Stillingar
 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
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{0}: {1} not found in Invoice Details table,{0}: {1} fannst ekki í Reikningsupplýsingar töflu
 DocType: Asset,Asset Owner Company,Eignarhaldsfélag
 DocType: Company,Round Off Cost Center,Umferð Off Kostnaður Center
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,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: Asset Maintenance Log,AML-,AML-
 DocType: Item,Material Transfer,efni Transfer
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Gat ekki fundið slóð fyrir
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +218,Opening (Dr),Opening (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221,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}
 apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Til að gera endurteknar skjöl
 ,GST Itemised Purchase Register,GST greidd kaupaskrá
@@ -861,12 +877,13 @@
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +316,Finish,Ljúka
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Base
 DocType: Timesheet,Total Billed Hours,Samtals Greidd Hours
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1463,Write Off Amount,Skrifaðu Off Upphæð
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1526,Write Off Amount,Skrifaðu Off Upphæð
 DocType: Leave Block List Allow,Allow User,að leyfa notanda
 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: Subscription,Quarterly,ársfjórðungslega
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47,EcritureLib,EcritureLib
 DocType: Lab Test Template,Grouped,Flokkað
 DocType: Selling Settings,Delivery Note Required,Afhending Note Áskilið
 DocType: Bank Guarantee,Bank Guarantee Number,Bankareikningsnúmer
@@ -875,7 +892,8 @@
 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ð
-DocType: Purchase Order Item Supplied,Reserve Warehouse,Reserve Vörugeymsla
+DocType: Sales Invoice,Port Code,Höfnarkóði
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Reserve Warehouse,Reserve Vörugeymsla
 DocType: Lead,Lead is an Organization,Lead er stofnun
 DocType: Guardian Interest,Interest,vextir
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Forsala
@@ -899,10 +917,10 @@
 DocType: Land Unit,Longitude,Lengdargráða
 ,Absent Student Report,Absent Student Report
 DocType: Crop,Crop Spacing UOM,Skera breiða UOM
+DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Veldu aðeins ef þú hefur sett upp Cash Flow Mapper skjöl
 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
 DocType: Supplier Scorecard,Per Week,Á viku
-apps/erpnext/erpnext/stock/doctype/item/item.py +639,Item has variants.,Liður hefur afbrigði.
+apps/erpnext/erpnext/stock/doctype/item/item.py +665,Item has variants.,Liður hefur afbrigði.
 apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Samtals nemandi
 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
@@ -921,20 +939,24 @@
 DocType: Purchase Order,Link to material requests,Tengill á efni beiðna
 DocType: Hub Settings,Publish,Birta
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Aerospace
+,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
 DocType: Journal Entry,Credit Card Entry,Credit Card Entry
 apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Fyrirtæki og reikningar
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,In Value,Virði
-apps/erpnext/erpnext/utilities/transaction_base.py +33,Invalid Posting Time,Ógildur póstur
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,In Value,Virði
+DocType: Asset Settings,Depreciation Options,Afskriftir Valkostir
+apps/erpnext/erpnext/utilities/transaction_base.py +35,Invalid Posting Time,Ógildur póstur
 DocType: Lead,Campaign Name,Heiti herferðar
+DocType: Hotel Room,Capacity,Stærð
 DocType: Selling Settings,Close Opportunity After Days,Loka Tækifæri Eftir daga
 ,Reserved,frátekin
 DocType: Driver,License Details,Leyfisupplýsingar
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85,The field From Shareholder cannot be blank,Svæðið frá Hluthafi getur ekki verið auður
 DocType: Purchase Order,Supply Raw Materials,Supply Raw Materials
 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 +104,{0} is not a stock Item,{0} er ekki birgðir Item
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +108,{0} is not a stock Item,{0} er ekki birgðir Item
 apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',Vinsamlegast deildu viðbrögðunum þínum við þjálfunina með því að smella á &#39;Þjálfunarniðurstaða&#39; og síðan &#39;Nýtt&#39;
 DocType: Mode of Payment Account,Default Account,Sjálfgefið Reikningur
-apps/erpnext/erpnext/stock/doctype/item/item.py +262,Please select Sample Retention Warehouse in Stock Settings first,Vinsamlegast veldu sýnishorn varðveisla vörugeymsla í lagerstillingum fyrst
+apps/erpnext/erpnext/stock/doctype/item/item.py +272,Please select Sample Retention Warehouse in Stock Settings first,Vinsamlegast veldu sýnishorn varðveisla vörugeymsla í lagerstillingum fyrst
 DocType: Payment Entry,Received Amount (Company Currency),Fékk Magn (Company Gjaldmiðill)
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,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
@@ -949,28 +971,27 @@
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Það er engin starfsmaður fyrir tiltekin skilyrði. Athugaðu að launagreiðslur hafi ekki þegar verið búnar til.
 apps/erpnext/erpnext/stock/reorder_item.py +194,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 +150,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/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
 DocType: Soil Texture,Sand,Sandur
 apps/erpnext/erpnext/setup/setup_wizard/data/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.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +874,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Row {0}: {1} Raðnúmer er nauðsynlegt fyrir lið {2}. Þú hefur veitt {3}.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +885,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Row {0}: {1} Raðnúmer er nauðsynlegt fyrir lið {2}. Þú hefur veitt {3}.
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Vinsamlegast veldu töflu
 DocType: BOM,Website Specifications,Vefsíða Upplýsingar
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} er ógilt netfang í &#39;viðtakendum&#39;
 DocType: Special Test Items,Particulars,Upplýsingar
-apps/erpnext/erpnext/config/healthcare.py +144,Antibiotic.,Sýklalyf.
 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 +310,Row {0}: Conversion Factor is mandatory,Row {0}: viðskipta Factor er nauðsynlegur
 DocType: Student,A+,A +
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +326,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","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 +504,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
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344,"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 +514,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: Asset,Maintenance,viðhald
 DocType: Item Attribute Value,Item Attribute Value,Liður Attribute gildi
 DocType: Item,Maximum sample quantity that can be retained,Hámarks sýni magn sem hægt er að halda
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +398,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Row {0} # Liður {1} er ekki hægt að flytja meira en {2} gegn innkaupapöntun {3}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +405,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},Row {0} # Liður {1} er ekki hægt að flytja meira en {2} gegn innkaupapöntun {3}
 apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Velta herferðir.
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,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.
@@ -1008,23 +1029,23 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Skrifstofa viðhald kostnaður
 apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Fara til
 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 +114,Please enter Item first,Vinsamlegast sláðu inn Item fyrst
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,Vinsamlegast sláðu inn Item fyrst
 DocType: Asset Repair,Downtime,Niður í miðbæ
 DocType: Account,Liability,Ábyrgð
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +234,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Bundnar Upphæð má ekki vera meiri en bótafjárhæðir í Row {0}.
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +218,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Bundnar Upphæð má ekki vera meiri en bótafjárhæðir í Row {0}.
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Academic Term: ,Fræðigrein:
 DocType: Salary Detail,Do not include in total,Ekki innifalið alls
 DocType: Company,Default Cost of Goods Sold Account,Default Kostnaðarverð seldra vara reikning
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +997,Sample quantity {0} cannot be more than received quantity {1},Sýni magn {0} getur ekki verið meira en móttekin magn {1}
-apps/erpnext/erpnext/stock/get_item_details.py +367,Price List not selected,Verðskrá ekki valið
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1005,Sample quantity {0} cannot be more than received quantity {1},Sýni magn {0} getur ekki verið meira en móttekin magn {1}
+apps/erpnext/erpnext/stock/get_item_details.py +369,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 +218,Warning: Invalid Attachment {0},Viðvörun: Ógild Attachment {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +227,Warning: Invalid Attachment {0},Viðvörun: Ógild Attachment {0}
 DocType: Item,Max Sample Quantity,Hámarksfjöldi sýnis
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +764,No Permission,engin heimild
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +438,Quote Requested,Tilvitnun
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766,No Permission,engin heimild
 DocType: Vital Signs,Heart Rate / Pulse,Hjartsláttur / púls
 DocType: Company,Default Bank Account,Sjálfgefið Bank Account
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +55,"To filter based on Party, select Party Type first","Að sía byggt á samningsaðila, velja Party Sláðu fyrst"
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59,"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/utilities/user_progress.py +143,Nos,nos
@@ -1042,35 +1063,39 @@
 DocType: Volunteer,Availability Timeslot,Framboð tímabils
 ,Support Analytics,Stuðningur Analytics
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Ef þú hefur einhverjar spurningar, vinsamlegast komast aftur til okkar."
+DocType: Cash Flow Mapper,Cash Flow Mapper,Cash Flow Mapper
 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/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Hladdu bréfshöfuðinu þínu (Haltu því á vefnum vingjarnlegur og 900px með 100px)
 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 +63,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 +284,Timesheet {0} is already completed or cancelled,Timesheet {0} er þegar lokið eða hætt
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +293,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: Item Variant Settings,Copy Fields to Variant,Afritaðu reiti í afbrigði
 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 +335,C-Form records,C-Form færslur
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73,The shares already exist,Hlutin eru þegar til
 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 +354,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.
 DocType: Setup Progress Action,Action Doctype,Aðgerð Doctype
 ,Production Order Stock Report,Framleiðslu Order Stock Report
-apps/erpnext/erpnext/config/healthcare.py +149,Sensitivity Naming.,Næmi nafngiftir
 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 +370,{0} against Bill {1} dated {2},{0} gegn frumvarpinu {1} dags {2}
+DocType: Production Plan,Select Items,Valið Atriði
+DocType: Share Transfer,To Shareholder,Til hluthafa
+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/utilities/user_progress.py +24,Setup Institution,Uppsetningarstofnun
 DocType: Program Enrollment,Vehicle/Bus Number,Ökutæki / rútu númer
 apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,námskeið Stundaskrá
 DocType: Request for Quotation Supplier,Quote Status,Tilvitnun Staða
 DocType: Maintenance Visit,Completion Status,Gengið Staða
+DocType: Daily Work Summary Group,Select Users,Veldu Notendur
+DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Hotel Herbergi Verðlagning
 DocType: HR Settings,Enter retirement age in years,Sláðu eftirlaunaaldur í ár
 DocType: Crop,Target Warehouse,Target Warehouse
 DocType: Payroll Employee Detail,Payroll Employee Detail,Launaskrá Starfsmannaupplýsingar
@@ -1080,9 +1105,9 @@
 DocType: Stock Entry,STE-,STE-
 DocType: Upload Attendance,Import Attendance,innflutningur Aðsókn
 apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Allir Item Hópar
-apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteLib,CompteLib
 apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},{0} {1} staðan er {2}
 DocType: Water Analysis,Collection Temperature ,Safn hitastig
 DocType: Employee,Provide Email Address registered in company,Gefa upp netfang skráð í félaginu
@@ -1091,9 +1116,10 @@
 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
 DocType: Drug Prescription,Interval UOM,Interval UOM
-apps/erpnext/erpnext/stock/doctype/item/item.js +490,Item Variant {0} already exists with same attributes,Liður Variant {0} er þegar til staðar með sömu eiginleika
+DocType: Customer,"Reselect, if the chosen address is edited after save","Veldu aftur, ef valið heimilisfang er breytt eftir að vista"
+apps/erpnext/erpnext/stock/doctype/item/item.js +492,Item Variant {0} already exists with same attributes,Liður Variant {0} er þegar til staðar með sömu eiginleika
 DocType: Item,Hub Publishing Details,Hub Publishing Upplýsingar
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +115,'Opening',&#39;Opening&#39;
+apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +114,'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: Lab Test Template,Result Format,Niðurstaða snið
@@ -1110,17 +1136,14 @@
 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/manufacturing/doctype/bom/bom.py +91,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Hráefni geta ekki verið eins og aðal atriði
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +93,BOM #{0}: Raw material cannot be same as main Item,BOM # {0}: Hráefni geta ekki verið eins og aðal atriði
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,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
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +64,Register for Hub,Skráðu þig fyrir Hub
 DocType: SMS Log,Requested Numbers,umbeðin Numbers
 DocType: Volunteer,Evening,Kvöld
-DocType: Production Planning Tool,Only Obtain Raw Materials,Aðeins fá hráefni
 DocType: Customer,Bypass credit limit check at Sales Order,Umframgreiðsla fyrir lánshæfiseinkunn í söluskilningi
 apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Mat á frammistöðu.
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +97,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","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/accounts/doctype/tax_rule/tax_rule.py +99,"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 +411,"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
@@ -1140,6 +1163,7 @@
 DocType: Salary Slip,Working Days,Vinnudagar
 DocType: Serial No,Incoming Rate,Komandi Rate
 DocType: Packing Slip,Gross Weight,Heildarþyngd
+,Final Assessment Grades,Lokamat
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Virkja Hub
 apps/erpnext/erpnext/public/js/setup_wizard.js +110,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
@@ -1152,20 +1176,22 @@
 DocType: Restaurant Table,Minimum Seating,Lágmarksstofa
 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 +843,Purchase Receipt,Kvittun
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845,Purchase Receipt,Kvittun
 ,Received Items To Be Billed,Móttekin Items verður innheimt
 apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Gengi meistara.
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +198,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 +322,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}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +204,Reference Doctype must be one of {0},Tilvísun DOCTYPE verður að vera einn af {0}
+apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,Sía Samtals núll Magn
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +341,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/manufacturing/doctype/bom/bom.py +585,BOM {0} must be active,BOM {0} verður að vera virkt
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +193,Closing (Opening + Total),Lokun (Opnun + Samtals)
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +595,BOM {0} must be active,BOM {0} verður að vera virkt
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +409,No Items available for transfer,Engar atriði í boði til að flytja
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218,Closing (Opening + Total),Lokun (Opnun + Samtals)
 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/accounts/report/general_ledger/general_ledger.js +111,Print in Account Currency,Prenta í reiknings Gjaldmiðill
+apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,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
 DocType: Crop Cycle,ISO 8016 standard,ISO 8016 staðall
+DocType: Pricing Rule,Rate or Discount,Verð eða afsláttur
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,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 +127,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.
@@ -1175,9 +1201,8 @@
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Búa til {0} Reikningur
 DocType: Medical Code,Medical Code Standard,Læknisfræðileg staðal
 DocType: Soil Texture,Clay Composition (%),Leir Samsetning (%)
-DocType: Production Planning Tool,Production Orders,framleiðslu Pantanir
 apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Vinsamlegast vista áður en verkefni er úthlutað.
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Balance Value,Balance Value
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74,Balance Value,Balance Value
 DocType: Lab Test,Lab Technician,Lab Tæknimaður
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Velta Verðskrá
 DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
@@ -1189,16 +1214,17 @@
 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/assets/doctype/asset/asset.py +276,Please enter Asset Category in Item {0},Vinsamlegast sláðu eignaflokki í lið {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +634,Item Variants {0} updated,Liður Afbrigði {0} uppfærð
+DocType: Item Barcode,Item Barcode,Liður Strikamerki
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +329,Please enter Asset Category in Item {0},Vinsamlegast sláðu eignaflokki í lið {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +660,Item Variants {0} updated,Liður Afbrigði {0} uppfærð
 DocType: Quality Inspection Reading,Reading 6,lestur 6
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
 of this",til að mynda. Ef seinkað verður þú að breyta handvirkt &quot;Repeat on Day of Month&quot; reitinn hér að neðan
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,Get ekki {0} {1} {2} án neikvætt framúrskarandi Reikningar
+DocType: Share Transfer,From Folio No,Frá Folio nr
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Kaupa Reikningar Advance
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +197,Row {0}: Credit entry can not be linked with a {1},Row {0}: Credit færslu er ekki hægt að tengja með {1}
+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 +246,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?
@@ -1208,27 +1234,28 @@
 DocType: Item,Is Purchase Item,Er Purchase Item
 DocType: Journal Entry Account,Purchase Invoice,kaup Invoice
 DocType: Stock Ledger Entry,Voucher Detail No,Skírteini Detail No
-apps/erpnext/erpnext/accounts/page/pos/pos.js +781,New Sales Invoice,Nýr reikningur
+apps/erpnext/erpnext/accounts/page/pos/pos.js +789,New Sales Invoice,Nýr reikningur
 DocType: Stock Entry,Total Outgoing Value,Alls Outgoing Value
 DocType: Physician,Appointments,Ráðnir
 apps/erpnext/erpnext/public/js/account_tree_grid.js +224,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
 ,LeaderBoard,LeaderBoard
 DocType: Sales Invoice Item,Rate With Margin (Company Currency),Meta með brún (Gjaldmiðill fyrirtækja)
-apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Offline Invoices,Sync Offline Reikningar
+apps/erpnext/erpnext/accounts/page/pos/pos.js +802,Sync Offline Invoices,Sync Offline Reikningar
 DocType: Payment Request,Paid,greiddur
 DocType: Program Fee,Program Fee,program Fee
 DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
 It also updates latest price in all the BOMs.","Skiptu ákveðnu BOM í öllum öðrum BOM þar sem það er notað. Það mun skipta um gamla BOM tengilinn, uppfæra kostnað og endurnýja &quot;BOM Explosion Item&quot; töflunni eins og á nýjum BOM. Það uppfærir einnig nýjustu verð í öllum BOMs."
 DocType: Salary Slip,Total in words,Samtals í orðum
 DocType: Material Request Item,Lead Time Date,Lead Time Dagsetning
+DocType: Asset,Available-for-use Date,Dagsetning í boði fyrir notkun
 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 +75, 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 +122,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Vinsamlegast tilgreinið Serial Nei fyrir lið {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +126,Row #{0}: Please specify Serial No for Item {1},Row # {0}: Vinsamlegast tilgreinið Serial Nei fyrir lið {1}
 DocType: Crop Cycle,Crop Cycle,Ræktunarhringur
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +632,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","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ð."
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633,"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: Student Admission,Publish on website,Birta á vefsíðu
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,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
@@ -1240,8 +1267,7 @@
 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 +917,Select Item for Transfer,Veldu Atriði til flutnings
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vinsamlegast settu Nöfnunarröð fyrir {0} í gegnum Skipulag&gt; Stillingar&gt; Nöfnunarröð
+DocType: Share Balance,Purchased,Keypt
 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: Agriculture Analysis Criteria,Soil Texture,Jarðvegur áferð
@@ -1250,20 +1276,20 @@
 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 +130,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/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/data/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 +775,All items have already been transferred for this Production Order.,Allir hlutir hafa þegar verið flutt í þessari framleiðslu Order.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +783,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/utilities/user_progress.py +144,Meter,Meter
 DocType: Workstation,Electricity Cost,rafmagn Kostnaður
+apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +22,Lab testing datetime cannot be before collection datetime,Lab prófunartímabil getur ekki verið fyrir dagsetningu söfnunartíma
 DocType: HR Settings,Don't send Employee Birthday Reminders,Ekki senda starfsmaður afmælisáminningar
 DocType: Expense Claim,Total Advance Amount,Samtals framvirði
 DocType: Delivery Stop,Estimated Arrival,Áætlaður komudagur
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Vista stillingar
 DocType: Delivery Stop,Notified by Email,Tilkynnt með tölvupósti
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +683,Requested Products,Beðið um vörur
 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
@@ -1272,10 +1298,12 @@
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,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/operations/install_fixtures.py +208,White,White
 DocType: SMS Center,All Lead (Open),Allt Lead (Open)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +253,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Row {0}: Magn er ekki í boði fyrir {4} í vöruhús {1} á að senda sinn færslunnar ({2} {3})
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +257,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})
+apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,Þú getur aðeins valið hámark einn valkosta af listanum yfir kassa.
 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 +808,Make ,gera
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635,Assigning {0} to {1} (row {2}),Úthluta {0} til {1} (röð {2})
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,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/hr/doctype/employee/employee_tree.js +29,New Employee,Ný starfsmaður
@@ -1285,23 +1313,22 @@
 DocType: Lead,Next Contact Date,Næsta samband við þann
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,opnun Magn
 DocType: Healthcare Settings,Appointment Reminder,Tilnefning tilnefningar
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +465,Please enter Account for Change Amount,Vinsamlegast sláðu inn reikning fyrir Change Upphæð
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +476,Please enter Account for Change Amount,Vinsamlegast sláðu inn reikning fyrir Change Upphæð
 DocType: Program Enrollment Tool Student,Student Batch Name,Student Hópur Name
 DocType: Consultation,Doctor,Læknir
 DocType: Holiday List,Holiday List Name,Holiday List Nafn
 DocType: Repayment Schedule,Balance Loan Amount,Balance lánsfjárhæð
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Dagskrá Námskeið
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234,Stock Options,Kaupréttir
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +235,Stock Options,Kaupréttir
 DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Gera óvinnufæran að sækja síðustu kaupupplýsingar í innkaupapöntun
 DocType: Journal Entry Account,Expense Claim,Expense Krafa
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +254,Do you really want to restore this scrapped asset?,Viltu virkilega að endurheimta rifið eign?
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +267,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 +381,Qty for {0},Magn {0}
 DocType: Leave Application,Leave Application,Leave Umsókn
 DocType: Patient,Patient Relation,Sjúklingar Tengsl
 apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Skildu Úthlutun Tól
 DocType: Item,Hub Category to Publish,Hub Flokkur til birtingar
 DocType: Leave Block List,Leave Block List Dates,Skildu Block Listi Dagsetningar
-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; Numbers Series
 DocType: Sales Invoice,Billing Address GSTIN,Innheimtu Heimilisfang GSTIN
 DocType: Assessment Plan,Evaluate,Meta
 DocType: Workstation,Net Hour Rate,Net Hour Rate
@@ -1313,12 +1340,14 @@
 apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Tilgreindu {0}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73,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.js +384,Variant creation has been queued.,Variant sköpun hefur verið í biðstöðu.
-apps/erpnext/erpnext/stock/doctype/item/item.py +668,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/stock/doctype/item/item.js +386,Variant creation has been queued.,Variant sköpun hefur verið í biðstöðu.
+apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100,Work Summary for {0},Vinna Yfirlit fyrir {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +695,Attribute table is mandatory,Eiginleiki borð er nauðsynlegur
+DocType: Production Plan,Get Sales Orders,Fá sölu skipunum
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68,{0} can not be negative,{0} er ekki hægt að neikvæð
 DocType: Training Event,Self-Study,Sjálfsnám
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +544,Discount,afsláttur
+apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +26,Soil compositions do not add up to 100,Jarðvegssamsetningar bæta ekki upp að 100
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +554,Discount,afsláttur
 DocType: Membership,Membership,Aðild
 DocType: Asset,Total Number of Depreciations,Heildarfjöldi Afskriftir
 DocType: Sales Invoice Item,Rate With Margin,Meta með skák
@@ -1327,19 +1356,19 @@
 DocType: Agriculture Task,Urgent,Urgent
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,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/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Ekki tókst að finna breytu:
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +746,Please select a field to edit from numpad,Vinsamlegast veldu reit til að breyta úr numpad
-apps/erpnext/erpnext/stock/doctype/item/item.py +253,Cannot be a fixed asset item as Stock Ledger is created.,Ekki er hægt að vera fast eignalýsing þar sem birgir er búið til.
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +790,Please select a field to edit from numpad,Vinsamlegast veldu reit til að breyta úr numpad
+apps/erpnext/erpnext/stock/doctype/item/item.py +263,Cannot be a fixed asset item as Stock Ledger is created.,Ekki er hægt að vera fast eignalýsing þar sem birgir er búið til.
 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: Quality Inspection Template,Quality Inspection Template Name,Gæði Skoðun sniðmát Nafn
 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 +71,Selling Amount,selja Upphæð
 DocType: Repayment Schedule,Interest Amount,vextir Upphæð
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +120,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: Share Transfer,Issue,Mál
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Records
 DocType: Asset,Scrapped,rifið
 DocType: Purchase Invoice,Returns,Skil
@@ -1352,17 +1381,17 @@
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,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: Delivery Trip,Delivery Trip,Afhendingartími
 DocType: Student,A-,A-
-DocType: Production Planning Tool,Include non-stock items,Fela ekki lager atriði
+DocType: Share Transfer,Transfer Type,Flutningsgerð
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,sölukostnaður
 DocType: Consultation,Diagnosis,Greining
 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 +1614,ZIP Code,Póstnúmer
-apps/erpnext/erpnext/controllers/selling_controller.py +248,Sales Order {0} is {1},Velta Order {0} er {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1623,ZIP Code,Póstnúmer
+apps/erpnext/erpnext/controllers/selling_controller.py +251,Sales Order {0} is {1},Velta Order {0} er {1}
 DocType: Opportunity,Contact Info,Contact Info
-apps/erpnext/erpnext/config/stock.py +315,Making Stock Entries,Gerð lager færslur
+apps/erpnext/erpnext/config/stock.py +319,Making Stock Entries,Gerð lager færslur
 DocType: Packing Slip,Net Weight UOM,Net Weight UOM
 DocType: Item,Default Supplier,Sjálfgefið Birgir
 DocType: Manufacturing Settings,Over Production Allowance Percentage,Yfir Production losunarheimilda Hlutfall
@@ -1370,9 +1399,9 @@
 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
+apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337,Invoice can't be made for zero billing hour,Reikningur er ekki hægt að gera í núll reikningstíma
 DocType: Sales Person,Select company name first.,Select nafn fyrirtækis fyrst.
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +181,Low to High,Lágt til hátt
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +202,Email sent to {0},Tölvupóstur sendur til {0}
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +201,Email sent to {0},Tölvupóstur sendur til {0}
 apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Tilvitnanir berast frá birgja.
 apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Skiptu um BOM og uppfærðu nýjustu verð í öllum BOMs
 apps/erpnext/erpnext/controllers/selling_controller.py +27,To {0} | {1} {2},Til {0} | {1} {2}
@@ -1382,7 +1411,8 @@
 apps/erpnext/erpnext/utilities/user_progress.py +107,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 +57,All BOMs,Allir BOMs
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +59,All BOMs,Allir BOMs
+apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Hótel Herbergi af tegund {0} eru ekki tiltækar á {1}
 DocType: Patient,Default Currency,sjálfgefið mynt
 DocType: Expense Claim,From Employee,frá starfsmanni
 DocType: Driver,Cellphone Number,gemsa númer
@@ -1391,16 +1421,16 @@
 DocType: Upload Attendance,Attendance From Date,Aðsókn Frá Dagsetning
 DocType: Appraisal Template Goal,Key Performance Area,Key Performance Area
 DocType: Program Enrollment,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 +229,{0} {1} must be submitted,{0} {1} Leggja skal fram
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +151,Quantity must be less than or equal to {0},Magn verður að vera minna en eða jafnt og {0}
+apps/erpnext/erpnext/controllers/item_variant.py +94,Invalid Attribute,Ógilt Attribute
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +235,{0} {1} must be submitted,{0} {1} Leggja skal fram
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,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
 DocType: Employee Advance,Claimed,Krafist
 DocType: Crop,Row Spacing,Row Spacing
 apps/erpnext/erpnext/controllers/buying_controller.py +164,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%
+apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38,Contribution %,framlag%
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","Eins og á kaupstillingum ef kaupin eru krafist == &#39;YES&#39; og síðan til að búa til innheimtufé, þarf notandi að búa til kauppöntun fyrst fyrir atriði {0}"
 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
@@ -1410,19 +1440,20 @@
 ,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 +226,Project Collaboration Invitation,Project Samvinna Boð
+apps/erpnext/erpnext/projects/doctype/project/project.py +228,Project Collaboration Invitation,Project Samvinna Boð
 DocType: Salary Slip,Deductions,frádráttur
 DocType: Leave Allocation,LAL/,LAL /
 DocType: Setup Progress Action,Action Name,Aðgerð heiti
 apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Start Ár
 apps/erpnext/erpnext/regional/india/utils.py +25,First 2 digits of GSTIN should match with State number {0},Fyrstu 2 stafirnir í GSTIN ættu að passa við ríkisnúmer {0}
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +58,PDC/LC,PDC / LC
 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 +366,Capacity Planning Error,Getu Planning Villa
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +385,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 +421,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/stock/doctype/stock_entry/stock_entry.py +428,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
 ,GST Sales Register,GST söluskrá
 DocType: Sales Invoice Advance,Sales Invoice Advance,Velta Invoice Advance
@@ -1430,17 +1461,19 @@
 apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Veldu lénin þín
 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}
 DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Fields verður afritað aðeins á upphafinu.
+DocType: Setup Progress Action,Domains,lén
 apps/erpnext/erpnext/projects/doctype/task/task.py +41,'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/operations/install_fixtures.py +117,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/buying/doctype/purchase_order/purchase_order.py +88,Caution,Varúð
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +813,Return / Debit Note,Return / skuldfærslu Note
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,Caution,Varúð
+apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +16,Start day is greater than end day in task '{0}',Upphafsdagur er meiri en lokadagur í verkefni &#39;{0}&#39;
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815,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 +209,{0} valid serial nos for Item {1},{0} gild raðnúmer nos fyrir lið {1}
+apps/erpnext/erpnext/stock/utils.py +212,{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
 DocType: Purchase Invoice Item,UOM Conversion Factor,UOM viðskipta Factor
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Vinsamlegast sláðu Item Code til að fá lotunúmer
@@ -1449,21 +1482,21 @@
 apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Veita upplýsingar.
 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 +748,Cost Center For Item with Item Code ',Kostnaður Center For lið með Item Code &#39;
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750,Cost Center For Item with Item Code ',Kostnaður Center For lið með Item Code &#39;
 DocType: Fee Validity,Valid Till,Gildir til
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2474,"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.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2500,"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.
 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 +30,"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 +97,Stock Entry {0} created,Stock Entry {0} búin
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Stock Entry {0} búin
 apps/erpnext/erpnext/controllers/buying_controller.py +316,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
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +45,Updating estimated arrival times.,Uppfærir áætlaða komutíma.
 DocType: Program Enrollment Tool,Enrollment Details,Upplýsingar um innritun
 DocType: Purchase Invoice Item,Net Rate,Net Rate
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +147,Please select a customer,Vinsamlegast veldu viðskiptavin
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152,Please select a customer,Vinsamlegast veldu viðskiptavin
 DocType: Purchase Invoice Item,Purchase Invoice Item,Kaupa Reikningar Item
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,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
@@ -1473,29 +1506,31 @@
 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/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Meðlimur Meðlimur
 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: Purchase Invoice,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 +446,'Entries' cannot be empty,&#39;Færslur&#39; má ekki vera autt
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,&#39;Færslur&#39; má ekki vera autt
 DocType: Maintenance Team Member,Maintenance Role,Viðhald Hlutverk
-apps/erpnext/erpnext/utilities/transaction_base.py +86,Duplicate row {0} with same {1},Afrit róður {0} með sama {1}
+apps/erpnext/erpnext/utilities/transaction_base.py +88,Duplicate row {0} with same {1},Afrit róður {0} með sama {1}
 ,Trial Balance,Trial Balance
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Reikningsár {0} fannst ekki
 apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Setja upp Starfsmenn
 DocType: Sales Order,SO-,SO-
+DocType: Hotel Room Reservation,Hotel Reservation User,Hotel Reservation User
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,Vinsamlegast veldu forskeyti fyrst
 DocType: Student,O-,O-
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,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
+apps/erpnext/erpnext/controllers/item_variant.py +35,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/assets/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 +500,"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/stock/doctype/item/item.py +525,"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"
 DocType: Crop Cycle,Less than a year,Minna en ár
 apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,Student Mobile No.
 apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Rest Of The World
@@ -1508,8 +1543,10 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,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/healthcare/doctype/patient_appointment/patient_appointment.py +112,Dr {0} on Leave on {1},Dr {0} á leyfi á {1}
 DocType: Purchase Invoice,Reverse Charge,Reverse Charge
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Óráðstafað eigið fé
+DocType: Purchase Invoice,05-Change in POS,05-Breyting á POS
 DocType: Vehicle Log,Service Detail,þjónusta Detail
 DocType: BOM,Item Description,Lýsing á hlut
 DocType: Student Sibling,Student Sibling,Student systkini
@@ -1522,7 +1559,7 @@
 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 +51,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/buying/doctype/request_for_quotation/request_for_quotation.py +53,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 +72,Temporary Opening,tímabundin Opening
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10,View Hub,Skoða miðstöð
 ,Employee Leave Balance,Starfsmaður Leave Balance
@@ -1544,9 +1581,8 @@
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Velta Order {0} er ekki gilt
 DocType: Supplier Scorecard,Warn for new Request for Quotations,Varið við nýja beiðni um tilboðsyfirlit
 apps/erpnext/erpnext/utilities/activation.py +91,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 +228,"Sorry, companies cannot be merged","Því miður, fyrirtæki geta ekki vera sameinuð"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Lab Test Prescriptions
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +162,"The total Issue / Transfer quantity {0} in Material Request {1}  \
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166,"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/operations/install_fixtures.py +197,Small,Lítil
 DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Opnun Reikningur Verkfæri Tól
@@ -1563,17 +1599,17 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Samningur
 DocType: Plant Analysis,Laboratory Testing Datetime,Laboratory Testing Datetime
 DocType: Email Digest,Add Quote,Bæta Quote
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +965,UOM coversion factor required for UOM: {0} in Item: {1},UOM coversion þáttur sem þarf til UOM: {0} í lið: {1}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +973,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 +92,Indirect Expenses,óbeinum kostnaði
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93,Row {0}: Qty is mandatory,Row {0}: Magn er nauðsynlegur
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +97,Row {0}: Qty is mandatory,Row {0}: Magn er nauðsynlegur
 DocType: Agriculture Analysis Criteria,Agriculture,Landbúnaður
-apps/erpnext/erpnext/accounts/page/pos/pos.js +786,Sync Master Data,Sync Master Data
+apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Master Data,Sync Master Data
 DocType: Asset Repair,Repair Cost,Viðgerðarkostnaður
 apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Vörur eða þjónustu
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Mistókst að skrá þig inn
 DocType: Special Test Items,Special Test Items,Sérstakar prófanir
 DocType: Mode of Payment,Mode of Payment,Háttur á greiðslu
-apps/erpnext/erpnext/stock/doctype/item/item.py +192,Website Image should be a public file or website URL,Vefsíða Image ætti að vera opinber skrá eða vefslóð
+apps/erpnext/erpnext/stock/doctype/item/item.py +201,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.
@@ -1582,7 +1618,7 @@
 DocType: Warehouse,Warehouse Contact Info,Warehouse Contact Info
 DocType: Payment Entry,Write Off Difference Amount,Skrifaðu Off Mismunur Upphæð
 DocType: Volunteer,Volunteer Name,Sjálfboðaliðanöfn
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434,"{0}: Employee email not found, hence email not sent","{0}: Starfsmaður tölvupósti fannst ekki, þess vegna email ekki sent"
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +433,"{0}: Employee email not found, hence email not sent","{0}: Starfsmaður tölvupósti fannst ekki, þess vegna email ekki sent"
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Sendingarregla gildir ekki fyrir land {0}
 DocType: Item,Foreign Trade Details,Foreign Trade Upplýsingar
 ,Assessment Plan Status,Mat á stöðu áætlunarinnar
@@ -1591,10 +1627,10 @@
 DocType: Purchase Invoice Item,Item Tax Rate,Liður Skatthlutfall
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Vinsamlegast veldu lækni og dagsetningu
 DocType: Student Group Student,Group Roll Number,Group Roll Number
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +143,"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 +80,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 +575,Delivery Note {0} is not submitted,Afhending Note {0} er ekki lögð
-apps/erpnext/erpnext/stock/get_item_details.py +146,Item {0} must be a Sub-contracted Item,Liður {0} verður að vera Sub-dregist Item
+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 +82,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 +586,Delivery Note {0} is not submitted,Afhending Note {0} er ekki lögð
+apps/erpnext/erpnext/stock/get_item_details.py +148,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 +43,Capital Equipments,Capital útbúnaður
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Verðlagning Regla er fyrst valið byggist á &#39;Virkja Á&#39; sviði, sem getur verið Item, Item Group eða Brand."
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +246,Please set the Item Code first,Vinsamlegast settu vörulistann fyrst
@@ -1603,7 +1639,7 @@
 DocType: Sales Invoice Item,Edit Description,Breyta Lýsing
 DocType: Antibiotic,Antibiotic,Sýklalyf
 ,Team Updates,Team uppfærslur
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +910,For Supplier,fyrir Birgir
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912,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
@@ -1618,7 +1654,8 @@
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,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 +204,Serial number {0} entered more than once,Raðnúmer {0} inn oftar en einu sinni
+DocType: Daily Work Summary Group,Reminder,Áminning
+apps/erpnext/erpnext/stock/utils.py +207,Serial number {0} entered more than once,Raðnúmer {0} inn oftar en einu sinni
 DocType: Journal Entry,Journal Entry,Dagbókarfærsla
 DocType: Expense Claim Advance,Unclaimed amount,Óhæfð upphæð
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,{0} atriði í gangi
@@ -1626,8 +1663,9 @@
 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 +591,BOM {0} does not belong to Item {1},BOM {0} ekki tilheyra lið {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +608,BOM {0} does not belong to Item {1},BOM {0} ekki tilheyra lið {1}
 DocType: Sales Partner,Target Distribution,Target Dreifing
+DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Lokagjöf á Bráðabirgðamati
 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: Supplier Scorecard,"Scorecard variables can be used, as well as:
@@ -1644,10 +1682,10 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Vélbúnaður
 DocType: Prescription Dosage,Prescription Dosage,Ávísun Skammtar
 DocType: Attendance,HR Manager,HR Manager
-apps/erpnext/erpnext/accounts/party.py +178,Please select a Company,Vinsamlegast veldu Company
+apps/erpnext/erpnext/accounts/party.py +176,Please select a Company,Vinsamlegast veldu Company
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Privilege Leave
 DocType: Purchase Invoice,Supplier Invoice Date,Birgir Dagsetning reiknings
-apps/erpnext/erpnext/templates/includes/product_page.js +18,per,á
+DocType: Asset Settings,This value is used for pro-rata temporis calculation,Þetta gildi er notað til tímabundinnar útreikninga
 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: Stock Settings,Naming Series Prefix,Heiti forskeyti fyrir nöfn
@@ -1657,6 +1695,7 @@
 DocType: Purchase Invoice,Party Account Currency,Party Reikningur Gjaldmiðill
 ,BOM Browser,BOM Browser
 apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Vinsamlegast uppfærðu stöðu þína fyrir þennan þjálfunarviðburð
+DocType: Item Barcode,EAN,EAN
 DocType: Purchase Taxes and Charges,Add or Deduct,Bæta eða draga
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,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
@@ -1665,7 +1704,6 @@
 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/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Viðhaldsáætlun {0} er til staðar gegn {1}
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +118,Do you want to publish your Items to Hub ?,Viltu birta hlutina þína í miðstöð?
 apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,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}
@@ -1680,19 +1718,17 @@
 DocType: Employee,EMP/,EMP /
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Vinsamlegast veldu lotur í lotuðum hlutum
 DocType: Asset,Depreciation Schedules,afskriftir Skrár
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +159,Following accounts might be selected in GST Settings:,Eftirfarandi reikningar gætu verið valin í GST stillingum:
-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
+apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192,Following accounts might be selected in GST Settings:,Eftirfarandi reikningar gætu verið valin í GST stillingum:
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,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 +30,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 +66,Approval Status must be 'Approved' or 'Rejected',Samþykki Staða verður &quot;Samþykkt&quot; eða &quot;Hafnað &#39;
 DocType: Physician,Contacts and Address,Tengiliðir og heimilisfang
 DocType: Purchase Invoice,Contact Person,Tengiliður
 apps/erpnext/erpnext/projects/doctype/task/task.py +38,'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;
@@ -1702,34 +1738,34 @@
 DocType: Purchase Invoice Item,Item Tax Amount,Liður Tax Upphæð
 DocType: Water Analysis,Water Analysis Criteria,Vatn greining Criteria
 DocType: Item,Maintain Stock,halda lager
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +222,Stock Entries already created for Production Order ,Lager Færslur nú þegar búið til framleiðslu Order
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +226,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
 DocType: Student Admission,Eligibility and Details,Hæfi og upplýsingar
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Net Breyting á fast eign
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38,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/controllers/accounts_controller.py +799,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 +382,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 +193,"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/buying/doctype/request_for_quotation/request_for_quotation.py +195,"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."
 DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Birgir Scorecard Scoring Variable
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Kaup Upphæð
 DocType: Sales Invoice,Shipping Address Name,Sendingar Address Nafn
 DocType: Material Request,Terms and Conditions Content,Skilmálar og skilyrði Content
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Það voru villur að búa til námskeiði
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +580,cannot be greater than 100,getur ekki verið meiri en 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +720,Item {0} is not a stock Item,Liður {0} er ekki birgðir Item
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581,cannot be greater than 100,getur ekki verið meiri en 100
+apps/erpnext/erpnext/stock/doctype/item/item.py +751,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 +139,"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
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +217,"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
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +343,Select POS Profile,Veldu POS prófíl
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +349,Select POS Profile,Veldu POS prófíl
 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
@@ -1747,14 +1783,13 @@
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,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 +243,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}
+apps/erpnext/erpnext/accounts/party.py +241,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 +183,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/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/config/healthcare.py +154,Lab Test Template.,Lab Test Sniðmát.
 DocType: Weather,Weather Parameter,Veðurparameter
 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: Lab Test Template,Collection Details,Safn Upplýsingar
@@ -1772,10 +1807,10 @@
 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 +154,Source warehouse is mandatory for row {0},Source vöruhús er nauðsynlegur fyrir röð {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +158,Source warehouse is mandatory for row {0},Source vöruhús er nauðsynlegur fyrir röð {0}
 apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Greiðslutími í röð {0} er hugsanlega afrit.
 apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Landbúnaður (beta)
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +856,Packing Slip,pökkun Slip
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858,Packing Slip,pökkun Slip
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,skrifstofa leigu
 apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Skipulag SMS Gateway stillingar
 DocType: Disease,Common Name,Algengt nafn
@@ -1797,25 +1832,26 @@
 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 +64,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 +305,Item Variants,Item Afbrigði
+apps/erpnext/erpnext/config/stock.py +309,Item Variants,Item Afbrigði
 apps/erpnext/erpnext/public/js/setup_wizard.js +29,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 +1039,Select Possible Supplier,Veldu Möguleg Birgir
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041,Select Possible Supplier,Veldu Möguleg Birgir
 DocType: Sales Invoice,Source,Source
+DocType: Customer,"Select, to make the customer searchable with these fields","Veldu, til að gera viðskiptavininum kleift að leita að þessum reitum"
 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 +250,Asset Category is mandatory for Fixed Asset item,Asset Flokkur er nauðsynlegur fyrir Fast eignalið
+apps/erpnext/erpnext/stock/doctype/item/item.py +260,Asset Category is mandatory for Fixed Asset item,Asset Flokkur er nauðsynlegur fyrir Fast eignalið
 DocType: Fee Validity,Fee Validity,Gjaldgildi
-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/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146,No records found in the Payment table,Engar færslur finnast í Greiðsla töflunni
 apps/erpnext/erpnext/education/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
 DocType: POS Profile,Apply Discount,gilda Afsláttur
 DocType: GST HSN Code,GST HSN Code,GST HSN kóða
 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 +286,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
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295,Packing Slip(s) cancelled,Pökkun Slip (s) Hætt
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36,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 +99,Freight and Forwarding Charges,Frakt og Áframsending Gjöld
 DocType: Homepage,Company Tagline for website homepage,Fyrirtæki Yfirskrift fyrir vefsvæðið heimasíðuna
@@ -1827,9 +1863,9 @@
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Stillingar sjálfgefið
 apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Búa Leiða
 DocType: Maintenance Schedule,Schedules,Skrár
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +458,POS Profile is required to use Point-of-Sale,POS Profile er nauðsynlegt til að nota Point-of-Sale
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +464,POS Profile is required to use Point-of-Sale,POS Profile er nauðsynlegt til að nota Point-of-Sale
 DocType: Purchase Invoice Item,Net Amount,Virði
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +138,{0} {1} has not been submitted so the action cannot be completed,{0} {1} hefur ekki verið send inn þannig að aðgerðin er ekki hægt að ljúka
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141,{0} {1} has not been submitted so the action cannot be completed,{0} {1} hefur ekki verið send inn þannig að aðgerðin er ekki hægt að ljúka
 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)
@@ -1846,13 +1882,14 @@
 DocType: Purchase Invoice,Select Shipping Address,Veldu Shipping Address
 apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Uppljómun Upplýsingar
 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
+apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220,Please input all required Result Value(s),Vinsamlegast settu inn allar nauðsynlegar niðurstöður gildi (s)
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94,Accounts Receivable Summary,Viðskiptakröfur Yfirlit
 DocType: Employee Loan,Monthly Repayment Amount,Mánaðarlega endurgreiðslu Upphæð
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Opnun Reikningar
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,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
 DocType: GST HSN Code,HSN Code,HSN kóða
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,framlag Upphæð
+apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39,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.
@@ -1860,13 +1897,14 @@
 DocType: Water Analysis,Container,Ílát
 apps/erpnext/erpnext/education/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: Healthcare Settings,Manage Sample Collection,Stjórna sýnishorni
+DocType: Production Plan,Ignore Existing Ordered Quantity,Hunsa núverandi skipað magn
 DocType: Patient,Tobacco Past Use,Notkun tóbaks í fortíðinni
 DocType: Sales Invoice Item,Brand Name,Vörumerki
 DocType: Purchase Receipt,Transporter Details,Transporter Upplýsingar
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},Notandi {0} er þegar úthlutað lækni {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2658,Default warehouse is required for selected item,Sjálfgefið vöruhús er nauðsynlegt til valið atriði
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2684,Default warehouse is required for selected item,Sjálfgefið vöruhús er nauðsynlegt til valið atriði
 apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Box
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1036,Possible Supplier,Möguleg Birgir
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038,Possible Supplier,Möguleg Birgir
 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
 apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Heilbrigðisþjónusta (beta)
@@ -1887,12 +1925,12 @@
 ,Lead Name,Lead Name
 ,POS,POS
 DocType: C-Form,III,III
-apps/erpnext/erpnext/config/stock.py +310,Opening Stock Balance,Opnun Stock Balance
+apps/erpnext/erpnext/config/stock.py +314,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/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 +42,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 +586,Manufacturing Quantity is mandatory,Framleiðsla Magn er nauðsynlegur
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +593,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
@@ -1901,37 +1939,38 @@
 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: Asset Maintenance Task,Certificate Required,Vottorð sem krafist er
 DocType: Company,Default Holiday List,Sjálfgefin Holiday List
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +190,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/projects/doctype/timesheet/timesheet.py +196,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 +145,Stock Liabilities,lager Skuldir
 DocType: Purchase Invoice,Supplier Warehouse,birgir Warehouse
 DocType: Opportunity,Contact Mobile No,Viltu samband við Mobile Nei
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +389,Select Company,Veldu fyrirtæki
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +395,Select Company,Veldu fyrirtæki
 ,Material Requests for which Supplier Quotations are not created,Efni Beiðnir sem Birgir tilvitnanir eru ekki stofnað
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,Notandi {0} hefur engin sjálfgefin POS prófíl. Kannaðu sjálfgefið í röð {1} fyrir þennan notanda.
 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/hr/doctype/leave_application/leave_application.py +123,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/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Row {idx}: {field} er nauðsynlegt til að búa til upphaf {invoice_type} reikninga
+DocType: Customer,Primary Address and Contact Detail,Aðal heimilisfang og tengiliðaval
 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
 DocType: Consultation,Appointment,Skipun
 apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,gera Tilvitnun
-apps/erpnext/erpnext/config/selling.py +216,Other Reports,aðrar skýrslur
+apps/erpnext/erpnext/config/education.py +226,Other Reports,aðrar skýrslur
 apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Vinsamlegast veldu að minnsta kosti eitt lén.
 DocType: Dependent Task,Dependent Task,Dependent Task
-apps/erpnext/erpnext/stock/doctype/item/item.py +430,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}
+apps/erpnext/erpnext/stock/doctype/item/item.py +443,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 +189,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/payroll_entry/payroll_entry.py +235,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 +1084,Search Item,leit Item
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1093,Search Item,leit Item
 DocType: Payment Schedule,Payment Amount,Greiðslu upphæð
 DocType: Patient Appointment,Referring Physician,Tilvísun læknir
 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
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100,Net Change in Cash,Net Breyting á Cash
 DocType: Assessment Plan,Grading Scale,flokkun Scale
-apps/erpnext/erpnext/stock/doctype/item/item.py +425,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 +617,Already completed,þegar lokið
+apps/erpnext/erpnext/stock/doctype/item/item.py +437,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 +639,Already completed,þegar lokið
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Lager í hendi
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Innflutningur Árangursrík!
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Greiðsla Beiðni þegar til staðar {0}
@@ -1948,10 +1987,12 @@
 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 +108,Conversion rate cannot be 0 or 1,Viðskiptahlutfall er ekki hægt að 0 eða 1
+DocType: Share Balance,To No,Til nr
 DocType: Subscription,Reference Document,Tilvísun Document
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +209,{0} {1} is cancelled or stopped,{0} {1} er aflýst eða henni hætt
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229,{0} {1} is cancelled or stopped,{0} {1} er aflýst eða henni hætt
 DocType: Accounts Settings,Credit Controller,Credit Controller
 DocType: Grant Application,Applicant Type,Umsækjandi Tegund
+DocType: Purchase Invoice,03-Deficiency in services,03-Skortur á þjónustu
 DocType: Delivery Note,Vehicle Dispatch Date,Ökutæki Sending Dagsetning
 DocType: Healthcare Settings,Default Medical Code Standard,Sjálfgefin Læknisfræðileg staðal
 DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
@@ -1959,7 +2000,6 @@
 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 +113,{0}% Billed,{0}% Billed
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +179,Sort by Price ...,Raða eftir Verð ...
 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
@@ -1969,7 +2009,7 @@
 DocType: BOM Item,BOM Item,BOM Item
 DocType: Appraisal,For Employee,fyrir starfsmann
 apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Gera útborgun færslu
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Supplier must be debit,Row {0}: Advance gegn Birgir skal gjaldfæra
+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: Membership,INR,INR
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,{Tíðni} Digest
@@ -1977,15 +2017,17 @@
 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/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Gegn Birgir Invoice {0} dagsett {1}
 DocType: Customer,Default Price List,Sjálfgefið Verðskrá
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +269,Asset Movement record {0} created,Eignastýring Hreyfing met {0} búin
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +322,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
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Viðskiptavinur með sama nafni er þegar til
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +183,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Þetta mun leggja inn launakostnað og búa til dagbókarfærslu. Viltu halda áfram?
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Þetta mun leggja inn launakostnað og búa til dagbókarfærslu. Viltu halda áfram?
 DocType: Purchase Invoice,Total Net Weight,Samtals nettóþyngd
+DocType: Purchase Invoice,Eligibility For ITC,Hæfi fyrir ITC
 DocType: Journal Entry,Entry Type,Entry Type
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +44,No assessment plan linked with this assessment group,Engin matsáætlun tengd þessari matshóp
 ,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/accounts/report/cash_flow/cash_flow.py +28,Net Change in Accounts Payable,Net Breyta í viðskiptaskuldum
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,EcritureLet,EcritureLet
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +211,Credit limit has been crossed for customer {0} ({1}/{2}),Lánshæfismat hefur verið farið fyrir viðskiptavininn {0} ({1} / {2})
 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 +140,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
@@ -2017,12 +2059,13 @@
 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
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +71,'Total',&#39;Total&#39;
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +178,'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 +258,"Advance paid against {0} {1} cannot be greater \
+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}
 DocType: Patient,Medication,Lyfjagjöf
+DocType: Production Plan,Include Non Stock Items,Inniheldur ekki hlutabréfaeign
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,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
@@ -2035,42 +2078,43 @@
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Online Uppboð
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,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 +18,Fulfillment,fylling
-apps/erpnext/erpnext/templates/generators/item.html +67,View in Cart,Skoða í körfu
+apps/erpnext/erpnext/templates/generators/item.html +82,View in Cart,Skoða í körfu
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,markaðskostnaður
 ,Item Shortage Report,Liður Skortur Report
-apps/erpnext/erpnext/stock/doctype/item/item.js +275,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Þyngd er getið, \ nVinsamlega nefna &quot;Þyngd UOM&quot; of"
+apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Ekki er hægt að búa til staðlaðar forsendur. Vinsamlegast breyttu viðmiðunum
+apps/erpnext/erpnext/stock/doctype/item/item.js +282,"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/assets/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
 DocType: Agriculture Task,Next Business Day,Næsta viðskiptadagur
-DocType: Customer,Primary Contact Detail,Aðal sambandsupplýsingar
 DocType: Drug Prescription,Dosage by time interval,Skammtur eftir tímabili
+DocType: Cash Flow Mapper,Section Header,Kaflaskipti
 ,Student Fee Collection,Student Fee Collection
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Skipunartími (mín.)
 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 +163,Warehouse required at Row No {0},Warehouse þörf á Row nr {0}
-apps/erpnext/erpnext/public/js/setup_wizard.js +142,Please enter valid Financial Year Start and End Dates,Vinsamlegast sláðu inn fjárhagsári upphafs- og lokadagsetningar
+apps/erpnext/erpnext/public/js/setup_wizard.js +145,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: Material Request,Transferred,Flutt
 DocType: Vehicle,Doors,hurðir
 apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,ERPNext Uppsetningu lokið!
 DocType: Healthcare Settings,Collect Fee for Patient Registration,Safna gjöld fyrir skráningu sjúklinga
-apps/erpnext/erpnext/stock/doctype/item/item.py +650,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Get ekki breytt eiginleiki eftir viðskipti með hlutabréf. Búðu til nýtt hlut og flytja birgðir til nýju hlutarins
+apps/erpnext/erpnext/stock/doctype/item/item.py +677,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Get ekki breytt eiginleiki eftir viðskipti með hlutabréf. Búðu til nýtt hlut og flytja birgðir til nýju hlutarins
 DocType: Course Assessment Criteria,Weightage,weightage
 DocType: Purchase Invoice,Tax Breakup,Tax Breakup
 DocType: Packing Slip,PS-,PS
 DocType: Member,Non Profit Member,Non Profit Member
 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.
 DocType: Payment Schedule,Payment Term,Greiðsluskilmálar
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +146,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/selling/doctype/customer/customer.py +162,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
 DocType: Land Unit,Area,Svæði
 apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,nýtt samband við
 DocType: Territory,Parent Territory,Parent Territory
-DocType: Sales Invoice,Place of Supply,Framboðsstaður
+DocType: Purchase Invoice,Place of Supply,Framboðsstaður
 DocType: Quality Inspection Reading,Reading 2,lestur 2
 DocType: Stock Entry,Material Receipt,efni Kvittun
 DocType: Homepage,Products,Vörur
@@ -2080,7 +2124,7 @@
 DocType: Student,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 +314,Quantity required for Item {0} in row {1},Magn krafist fyrir lið {0} í röð {1}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Quantity required for Item {0} in row {1},Magn krafist fyrir lið {0} í röð {1}
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,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
 ,Item-wise Sales Register,Item-vitur Sales Register
@@ -2100,79 +2144,81 @@
 DocType: Student Group Instructor,Student Group Instructor,Nemandi hópur kennari
 DocType: Grant Application,Assessment  Mark (Out of 10),Námsmat (af 10)
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,Guardian2 Mobile No
-apps/erpnext/erpnext/setup/doctype/company/company.py +207,Main,Main
+apps/erpnext/erpnext/setup/doctype/company/company.py +218,Main,Main
 apps/erpnext/erpnext/stock/doctype/item/item.js +72,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 +444,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
+apps/erpnext/erpnext/stock/doctype/item/item.py +457,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 +1137,Make Purchase Order,Gera Purchase Order
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1139,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}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +134,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 +197,Work-in-Progress Warehouse is required before Submit,Work-í-gangi Warehouse er krafist áður Senda
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +204,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/education/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 +250,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/accounts/doctype/payment_entry/payment_entry.py +256,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 +142,Appraisals,úttektir
 apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Þjálfun viðburðir
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,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 +167,Please enter ,vinsamlegast sláðu
-apps/erpnext/erpnext/controllers/accounts_controller.py +487,"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/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Viðhaldsskrá
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +234,Please set filter based on Item or Warehouse,Vinsamlegast settu síuna miðað Item eða Warehouse
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236,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/selling/page/point_of_sale/point_of_sale.js +798,Discount amount cannot be greater than 100%,Afsláttarfjárhæð getur ekki verið meiri en 100%
 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 +588,BOM {0} must be submitted,BOM {0} Leggja skal fram
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +598,BOM {0} must be submitted,BOM {0} Leggja skal fram
+apps/erpnext/erpnext/config/accounts.py +460,Share Management,Hlutastýring
 DocType: Authorization Control,Authorization Control,Heimildin Control
 apps/erpnext/erpnext/controllers/buying_controller.py +327,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 +808,Payment,greiðsla
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Payment,greiðsla
 apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","Vörugeymsla {0} er ekki tengt neinum reikningi, vinsamlegast tilgreinið reikninginn í vörugeymslunni eða settu sjálfgefið birgðareikning í félaginu {1}."
 apps/erpnext/erpnext/utilities/activation.py +81,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}
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56,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: Crop,Crop Spacing,Crop Spacing
 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/assets/doctype/asset/asset.py +164,"Asset cannot be cancelled, as it is already {0}","Eign er ekki hætt, eins og það er nú þegar {0}"
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +217,"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 +42,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: Material Request Plan Item,Actual Qty,Raunveruleg Magn
 DocType: Sales Invoice Item,References,Tilvísanir
 DocType: Quality Inspection Reading,Reading 10,lestur 10
+DocType: Item,Barcodes,Strikamerki
 DocType: Hub Category,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/operations/install_fixtures.py +129,Associate,Félagi
 DocType: Asset Movement,Asset Movement,Asset Hreyfing
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2181,New Cart,nýtt körfu
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2199,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: Patient Relation,Family,Fjölskylda
-DocType: Production Planning Tool,Material Requests,efni Beiðnir
+DocType: Production Plan,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/data/industry_type.py +52,Telecommunications,Fjarskipti
-apps/erpnext/erpnext/accounts/party.py +266,Billing currency must be equal to either default company's currency or party account currency,Innheimtargjald verður að vera jafnt gjaldmiðli gjaldmiðils eða félagsreiknings gjaldmiðils
+apps/erpnext/erpnext/accounts/party.py +264,Billing currency must be equal to either default company's currency or party account currency,Innheimtargjald verður að vera jafnt gjaldmiðli gjaldmiðils eða félagsreiknings gjaldmiðils
 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)
 DocType: Soil Texture,Loam,Loam
 apps/erpnext/erpnext/controllers/accounts_controller.py +700,Row {0}: Due Date cannot be before posting date,Row {0}: Gjalddagi má ekki vera fyrir útgáfudegi
@@ -2189,21 +2235,22 @@
 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}"
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"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/controllers/accounts_controller.py +487,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings",Ekki er hægt að yfirfæra fyrir lið {0} í röð {1} meira en {2}. Til að leyfa ofgreiðslu skaltu setja í lagerstillingar
 apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Uppfæra svar
-apps/erpnext/erpnext/public/js/utils.js +226,You have already selected items from {0} {1},Þú hefur nú þegar valið hluti úr {0} {1}
+apps/erpnext/erpnext/public/js/utils.js +232,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 +46,Batch ID is mandatory,Hópur auðkenni er nauðsynlegur
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Hópur auðkenni er nauðsynlegur
 DocType: Sales Person,Parent Sales Person,Móðurfélag Sales Person
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +180,High to Low,Hátt til lágt
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100,The seller and the buyer cannot be the same,Seljandi og kaupandi geta ekki verið þau sömu
 apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Veldu forritið fyrst
 DocType: Patient Appointment,Patient Age,Sjúklingur Aldur
-apps/erpnext/erpnext/config/learn.py +263,Managing Projects,Annast verkefni
+apps/erpnext/erpnext/config/learn.py +253,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: Asset Maintenance Log,Planned,Planað
@@ -2211,13 +2258,13 @@
 DocType: Vehicle Log,Fuel Price,eldsneyti verð
 DocType: Budget,Budget,Budget
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Setja opinn
-apps/erpnext/erpnext/stock/doctype/item/item.py +247,Fixed Asset Item must be a non-stock item.,Fast Asset Item verður a non-birgðir atriði.
+apps/erpnext/erpnext/stock/doctype/item/item.py +257,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 +66,Territory / Customer,Territory / Viðskiptavinur
 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}
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,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: Lead,Follow Up,Fylgja eftir
 DocType: Item,Is Sales Item,Er Sales Item
@@ -2225,9 +2272,10 @@
 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/manufacturing/doctype/bom/bom.py +324,Same item has been entered multiple times. {0},Sama hlutur hefur verið færður inn mörgum sinnum. {0}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +334,Same item has been entered multiple times. {0},Sama hlutur hefur verið færður inn mörgum sinnum. {0}
 apps/erpnext/erpnext/education/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.
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +192,There were errors.,Það voru villur.
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190,There were errors.,Það voru villur.
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +167,Employee {0} has already applied for {1} between {2} and {3} : ,Starfsmaður {0} hefur þegar sótt um {1} á milli {2} og {3}:
 DocType: Guardian,Guardian Interests,Guardian Áhugasvið
 DocType: Naming Series,Current Value,Núverandi Value
 apps/erpnext/erpnext/controllers/accounts_controller.py +272,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
@@ -2243,18 +2291,21 @@
 						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 +379,Amount {0} {1} deducted against {2},Upphæð {0} {1} frádráttar {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +385,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 +311,Due Date cannot be before Posting Date,Skiladagur er ekki hægt áður Staða Dagsetning
+apps/erpnext/erpnext/accounts/party.py +309,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/hr/doctype/payroll_entry/payroll_entry.py +458,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Engin launaspjald fannst fyrir framangreindar valin skilyrði
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Skyldur og skattar
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Please enter Reference date,Vinsamlegast sláðu viðmiðunardagur
+DocType: Projects Settings,Projects Settings,Verkefni Stillingar
+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.
+DocType: Production Plan,Total Produced Qty,Heildarframleiðsla
 DocType: Payroll Entry,Get Employee Details,Fáðu starfsmannaupplýsingar
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,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
@@ -2263,12 +2314,13 @@
 DocType: Account,Frozen,Frozen
 ,Open Production Orders,Opið Framleiðslu Pantanir
 DocType: Sales Invoice Payment,Base Amount (Company Currency),Base Magn (Company Gjaldmiðill)
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +919,Raw Materials,Hráefni
 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 +113,Delete all the Transactions for this Company,Eyða öllum viðskiptum fyrir þetta fyrirtæki
 DocType: Patient,O Positive,O Jákvæð
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +200,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} 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/stock/doctype/stock_entry/stock_entry.py +204,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Row # {0}: Operation {1} 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 +68,Investments,Fjárfestingar
 DocType: Issue,Resolution Details,upplausn Upplýsingar
 apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,úthlutanir
@@ -2295,7 +2347,7 @@
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Greiða
 DocType: Room,Room Name,Room Name
 DocType: Prescription Duration,Prescription Duration,Ávísunartími
-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}"
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +82,"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
 apps/erpnext/erpnext/config/selling.py +229,Customer Addresses And Contacts,Viðskiptavinur heimilisföngum og Tengiliðir
 ,Campaign Efficiency,Virkni herferðar
@@ -2305,24 +2357,27 @@
 DocType: Patient,Surgical History,Skurðaðgerðarsaga
 DocType: Employee,Resignation Letter Date,Störfum Letter Dagsetning
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,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 +335,Please set the Date Of Joining for employee {0},Vinsamlegast settu Dagsetning Tengingar fyrir starfsmann {0}
+apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +131,Not Set,ekki Sett
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +334,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
 DocType: Soil Texture,Silty Clay Loam,Silty Clay Loam
 DocType: Chapter,Chapter,Kafli
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +200,{0} ({1}) must have role 'Expense Approver',{0} ({1}) verða að hafa hlutverk &#39;kostnað samþykkjari&#39;
 apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,pair
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +959,Select BOM and Qty for Production,Veldu BOM og Magn fyrir framleiðslu
+DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Sjálfgefin reikningur verður sjálfkrafa uppfærð í POS Reikningur þegar þessi stilling er valin.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +961,Select BOM and Qty for Production,Veldu BOM og Magn fyrir framleiðslu
 DocType: Asset,Depreciation Schedule,Afskriftir Stundaskrá
 apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Söluaðilar samstarfsaðilar og tengiliðir
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Vörunúmer&gt; Liðurhópur&gt; Vörumerki
 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ð
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +53,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
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139,Please set the Default Cost Center in {0} company.,Vinsamlega stilltu sjálfgefna kostnaðarmiðstöðina í {0} fyrirtæki.
 DocType: Item,Has Batch No,Hefur Batch No
-apps/erpnext/erpnext/public/js/utils.js +100,Annual Billing: {0},Árleg Billing: {0}
+apps/erpnext/erpnext/public/js/utils.js +106,Annual Billing: {0},Árleg Billing: {0}
 apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Vörur og þjónusta Skattur (GST Indland)
 DocType: Delivery Note,Excise Page Number,Vörugjöld Page Number
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +225,"Company, From Date and To Date is mandatory","Company, Frá Dagsetning og hingað til er nauðsynlegur"
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227,"Company, From Date and To Date is mandatory","Company, Frá Dagsetning og hingað til er nauðsynlegur"
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Komdu frá samráði
 DocType: Asset,Purchase Date,kaupdegi
 DocType: Volunteer,Volunteer Type,Sjálfboðaliðar
@@ -2331,11 +2386,11 @@
 ,Maintenance Schedules,viðhald Skrár
 DocType: Task,Actual End Date (via Time Sheet),Raunveruleg End Date (með Time Sheet)
 DocType: Soil Texture,Soil Type,Jarðvegsgerð
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Amount {0} {1} against {2} {3},Upphæð {0} {1} gegn {2} {3}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +318,New Message,Ný skilaboð
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +380,Amount {0} {1} against {2} {3},Upphæð {0} {1} gegn {2} {3}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,New Message,Ný skilaboð
 ,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 +355,Debit To account must be a Receivable account,Debit Til reikning verður að vera Krafa reikning
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160,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 +366,Debit To account must be a Receivable account,Debit Til reikning verður að vera Krafa reikning
 DocType: Shipping Rule,Shipping Amount,Sendingar Upphæð
 DocType: Supplier Scorecard Period,Period Score,Tímabilsstig
 apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Bæta við viðskiptavinum
@@ -2346,7 +2401,7 @@
 ,Vehicle Expenses,ökutæki Útgjöld
 DocType: Serial No,Invoice Details,Reikningsupplýsingar
 DocType: Grant Application,Show on Website,Sýna á heimasíðu
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +159,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}
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +212,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}
 apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Byrjaðu á
 DocType: Hub Category,Hub Category,Hub Flokkur
 DocType: Purchase Invoice,SEZ,SEZ
@@ -2355,10 +2410,11 @@
 apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Bættu við bréfinu
 DocType: Program Enrollment,Self-Driving Vehicle,Sjálfknúin ökutæki
 DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Birgir Stuðningskort Standandi
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +420,Row {0}: Bill of Materials not found for the Item {1},Row {0}: Efnislisti finnst ekki fyrir þar sem efnið {1}
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +442,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
+DocType: Purchase Invoice,Availed ITC Central Tax,Notaður ITC Central Tax
 DocType: Salary Structure,Select employees for current Salary Structure,Valið starfsmenn líðandi laun uppbyggingu
 DocType: Sales Invoice,Company Address Name,Nafn fyrirtækis fyrirtækis
 DocType: Production Order,Use Multi-Level BOM,Notaðu Multi-Level BOM
@@ -2366,18 +2422,20 @@
 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/hooks.py +144,Timesheets,timesheets
+DocType: Projects Settings,Timesheets,timesheets
 DocType: HR Settings,HR Settings,HR Stillingar
 DocType: Salary Slip,net pay info,nettó borga upplýsingar
 DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Þetta gildi er uppfært í Sjálfgefin söluverðalista.
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +122,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
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79,PDC/LC Amount,PDC / LC upphæð
+DocType: Shareholder,Shareholder,Hluthafi
 DocType: Purchase Invoice,Additional Discount Amount,Viðbótarupplýsingar Afsláttur Upphæð
+DocType: Cash Flow Mapper,Position,Staða
 DocType: Patient,Patient Details,Sjúklingur Upplýsingar
 DocType: Patient,B Positive,B Jákvæð
 apps/erpnext/erpnext/controllers/accounts_controller.py +595,"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 +310,Abbr can not be blank or space,Skammstöfun má ekki vera autt eða bil
+apps/erpnext/erpnext/setup/doctype/company/company.py +317,Abbr can not be blank or space,Skammstöfun má ekki vera autt eða bil
 DocType: Patient Medical Record,Patient Medical Record,Sjúkratryggingaskrá
 apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Group Non-Group
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Íþróttir
@@ -2385,10 +2443,12 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,alls Raunveruleg
 DocType: Lab Test UOM,Test UOM,Prófaðu UOM
 DocType: Student Siblings,Student Siblings,Student Systkini
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Birgir&gt; Birgir Tegund
 apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Unit
-apps/erpnext/erpnext/stock/get_item_details.py +136,Please specify Company,Vinsamlegast tilgreinið Company
+apps/erpnext/erpnext/stock/get_item_details.py +138,Please specify Company,Vinsamlegast tilgreinið Company
 ,Customer Acquisition and Loyalty,Viðskiptavinur Kaup og Hollusta
 DocType: Asset Maintenance Task,Maintenance Task,Viðhaldsviðskipti
+apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118,Please set B2C Limit in GST Settings.,Vinsamlegast stilltu B2C takmörk í GST stillingum.
 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 +109,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
@@ -2413,50 +2473,52 @@
 DocType: Item,Retain Sample,Halda sýni
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,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 +354,Item Price added for {0} in Price List {1},Atriði Verð bætt fyrir {0} í verðskrá {1}
+apps/erpnext/erpnext/stock/get_item_details.py +356,Item Price added for {0} in Price List {1},Atriði Verð bætt fyrir {0} í verðskrá {1}
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Vinsamlegast skipulag kennari Nafnakerfi í menntun&gt; Menntun
 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/stock/report/item_variant_details/item_variant_details.py +71,In Production,Í framleiðslu
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +59,Difference Amount must be zero,Munurinn Upphæð verður að vera núll
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +60,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 +61,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
 DocType: Normal Test Template,Normal Test Template,Venjulegt próf sniðmát
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,fatlaður notandi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +913,Quotation,Tilvitnun
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +982,Cannot set a received RFQ to No Quote,Ekki er hægt að stilla móttekið RFQ til neins vitna
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919,Quotation,Tilvitnun
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984,Cannot set a received RFQ to No Quote,Ekki er hægt að stilla móttekið RFQ til neins vitna
 DocType: Quotation,QTN-,QTN-
 DocType: Salary Slip,Total Deduction,Samtals Frádráttur
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +15,Select an account to print in account currency,Veldu reikning til að prenta í reiknings gjaldmiðli
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18,Select an account to print in account currency,Veldu reikning til að prenta í reiknings gjaldmiðli
 ,Production Analytics,framleiðslu Analytics
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Þetta byggist á viðskiptum gegn þessum sjúklingum. Sjá tímalínu fyrir neðan til að fá nánari upplýsingar
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +201,Cost Updated,kostnaður Uppfært
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +203,Cost Updated,kostnaður Uppfært
 DocType: Patient,Date of Birth,Fæðingardagur
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,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
 DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Birgir Scorecard Skipulag
 apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Námsmat
-apps/erpnext/erpnext/stock/doctype/item/item.py +222,Warning: Invalid SSL certificate on attachment {0},Viðvörun: Ógild SSL vottorð á viðhengi {0}
+apps/erpnext/erpnext/stock/doctype/item/item.py +232,Warning: Invalid SSL certificate on attachment {0},Viðvörun: Ógild SSL vottorð á viðhengi {0}
 apps/erpnext/erpnext/utilities/activation.py +64,"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/operations/install_fixtures.py +236,Job Description,Starfslýsing
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Job Description,Starfslýsing
 DocType: Student Applicant,Applied,Applied
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +863,Re-open,Re-opinn
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Re-open,Re-opinn
 DocType: Sales Invoice Item,Qty as per Stock UOM,Magn eins og á lager UOM
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Guardian2 Name
+DocType: Purchase Invoice,02-Post Sale Discount,02-Post Sala Afsláttur
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"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
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91,The field To Shareholder cannot be blank,Reitinn til hluthafa má ekki vera auður
 DocType: Guardian,Work Address,vinna Address
 DocType: Appraisal,Calculate Total Score,Reikna aðaleinkunn
 DocType: Asset Repair,Manufacturing Manager,framleiðsla Manager
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},Serial Nei {0} er undir ábyrgð uppí {1}
 DocType: Plant Analysis Criteria,Minimum Permissible Value,Lágmarks leyfilegt gildi
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +42,User {0} already exists,Notandi {0} er þegar til
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41,User {0} already exists,Notandi {0} er þegar til
 apps/erpnext/erpnext/hooks.py +109,Shipments,sendingar
 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
@@ -2464,6 +2526,7 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,Serial Nei {0} er ekki tilheyra neinum Warehouse
 DocType: Grant Application,Email Notification Sent,Email tilkynning send
 DocType: Purchase Invoice,In Words (Company Currency),Í orðum (Company Gjaldmiðill)
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1009,"Item Code, warehouse, quantity are required on row","Vörunúmer, vörugeymsla, magn er krafist í röð"
 DocType: Pricing Rule,Supplier,birgir
 apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Sýna greiðsluupplýsingar
 DocType: Consultation,Consultation Time,Samráðstími
@@ -2482,22 +2545,24 @@
 apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,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 +228,"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 +421,{0} is mandatory for Item {1},{0} er nauðsynlegur fyrir lið {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +432,{0} is mandatory for Item {1},{0} er nauðsynlegur fyrir lið {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136,"Item {0}: {1} qty produced, ","Liður {0}: {1} Magn framleitt,"
 DocType: Payroll Entry,Fortnightly,hálfsmánaðarlega
 DocType: Currency Exchange,From Currency,frá Gjaldmiðill
 DocType: Vital Signs,Weight (In Kilogram),Þyngd (í kílógramm)
 DocType: Chapter,"chapters/chapter_name
 leave blank automatically set after saving chapter.",kaflar / kafli_nafn slepptu sjálfkrafa eftir að þú hefur vistað kafla.
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +169,Please set GST Accounts in GST Settings,Vinsamlegast settu GST reikninga í GST stillingum
+apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,Please set GST Accounts in GST Settings,Vinsamlegast settu GST reikninga í GST stillingum
 apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31,Type of Business,Tegund viðskipta
-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/doctype/payment_reconciliation/payment_reconciliation.py +171,"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 +128,Cost of New Purchase,Kostnaður við nýja kaup
+apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35,All tasks for the detected diseases were imported,Öll verkefni fyrir greindar sjúkdóma voru fluttar inn
 apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Velta Order krafist fyrir lið {0}
 DocType: Grant Application,Grant Description,Grant Lýsing
 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 +71,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}.
+apps/erpnext/erpnext/templates/includes/product_page.js +90,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
@@ -2512,19 +2577,21 @@
 DocType: Bin,Ordered Quantity,Raðaður Magn
 apps/erpnext/erpnext/public/js/setup_wizard.js +118,"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/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Hagnaður ársins
 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: Fee Schedule,In Process,Í ferli
 DocType: Authorization Rule,Itemwise Discount,Itemwise Afsláttur
 apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Tré ársreikning.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +362,{0} against Sales Order {1},{0} gegn Velta Order {1}
+DocType: Cash Flow Mapping,Cash Flow Mapping,Cash Flow Kortlagning
+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 +320,Serialized Inventory,serialized Inventory
+apps/erpnext/erpnext/config/stock.py +324,Serialized Inventory,serialized Inventory
+apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,Tölvupóstur fannst ekki í vanrækslu sambandi
 DocType: Employee Loan,Account Info,Reikningur Upplýsingar
 DocType: Activity Type,Default Billing Rate,Sjálfgefið Billing Rate
 DocType: Fees,Include Payment,Hafa greiðslu
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{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/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Forrit í gjaldskrárbyggingu og nemendahópnum {0} eru mismunandi.
 DocType: Fee Schedule,Receivable Account,viðskiptakröfur Reikningur
 apps/erpnext/erpnext/controllers/accounts_controller.py +617,Row #{0}: Asset {1} is already {2},Row # {0}: Asset {1} er þegar {2}
@@ -2536,8 +2603,9 @@
 DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLICATE FOR SUPPLIER
 DocType: Land Unit,Is Container,Er ílát
 DocType: Crop Cycle,This will be day 1 of the crop cycle,Þetta verður dagur 1 í ræktunarferlinu
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +869,Please select correct account,Vinsamlegast veldu réttan reikning
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871,Please select correct account,Vinsamlegast veldu réttan reikning
 DocType: Purchase Invoice Item,Weight UOM,þyngd UOM
+apps/erpnext/erpnext/config/accounts.py +466,List of available Shareholders with folio numbers,Listi yfir tiltæka hluthafa með folíumnúmerum
 DocType: Salary Structure Employee,Salary Structure Employee,Laun Uppbygging Starfsmaður
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Sýna Variant Eiginleikar
 DocType: Student,Blood Group,Blóðflokkur
@@ -2548,6 +2616,7 @@
 DocType: Fiscal Year,Companies,Stofnanir
 DocType: Supplier Scorecard,Scoring Setup,Skora uppsetning
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Electronics
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326,Debit ({0}),Skuldfærslu ({0})
 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/operations/install_fixtures.py +98,Full-time,Fullt
 DocType: Payroll Entry,Employees,starfsmenn
@@ -2558,23 +2627,22 @@
 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
 DocType: Stock Entry,Total Incoming Value,Alls Komandi Value
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +349,Debit To is required,Skuldfærslu Til er krafist
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +360,Debit To is required,Skuldfærslu Til er krafist
 apps/erpnext/erpnext/utilities/activation.py +109,"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
 apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Sniðmát af birgðatölumörkum.
-DocType: Offer Letter Term,Offer Term,Tilboð Term
+DocType: Job Offer Term,Offer Term,Tilboð Term
 DocType: Asset,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 +153,Please select Incharge Person's name,Vinsamlegast veldu nafn incharge einstaklingsins
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,tækni
 DocType: Hub Settings,Unregister from Hub,Afskráðu frá Hub
-apps/erpnext/erpnext/public/js/utils.js +102,Total Unpaid: {0},Samtals Ógreitt: {0}
+apps/erpnext/erpnext/public/js/utils.js +108,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.
 DocType: Supplier Scorecard,Supplier Score,Birgiratriði
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +87,Total Invoiced Amt,Alls reikningsfærð Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +194,Total Invoiced Amt,Alls reikningsfærð Amt
 DocType: Supplier,Warn RFQs,Varða RFQs
 DocType: BOM,Conversion Rate,Viðskiptahlutfallsbil
 apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Vöruleit
@@ -2582,17 +2650,17 @@
 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 +118,Credit To account must be a Payable account,Inneign á reikninginn verður að vera Greiðist reikning
 apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Vinsamlegast veljið Student Entrance sem er skylt fyrir greiddan nemanda
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +338,BOM recursion: {0} cannot be parent or child of {2},BOM endurkvæmni: {0} er ekki hægt að foreldri eða barn {2}
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +23,Please select a Price List to publish pricing,Vinsamlegast veldu verðlista til að birta verðlagningu
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +348,BOM recursion: {0} cannot be parent or child of {2},BOM endurkvæmni: {0} er ekki hægt að foreldri eða barn {2}
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21,Please select a Price List to publish pricing,Vinsamlegast veldu verðlista til að birta verðlagningu
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Fjárhagsáætlunarlisti
 DocType: Production Order Operation,Completed Qty,lokið Magn
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +146,"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/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 +127,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 +148,"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/stock_entry/stock_entry.py +1009,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Hámarksýni - {0} er hægt að halda í lotu {1} og lið {2}.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1017,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Hámarksýni - {0} er hægt að halda í lotu {1} og lið {2}.
 apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Bæta við tímaslóðum
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{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
@@ -2602,6 +2670,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Gengishagnaður / tap
 DocType: Opportunity,Lost Reason,Lost Ástæða
 apps/erpnext/erpnext/controllers/accounts_controller.py +264,Row #{0}: Account {1} does not belong to company {2},Row # {0}: Reikningur {1} tilheyrir ekki fyrirtæki {2}
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},Gat ekki fundið DocType {0}
 apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,ný Address
 DocType: Quality Inspection,Sample Size,Prufustærð
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Vinsamlegast sláðu inn Kvittun Skjal
@@ -2610,7 +2679,7 @@
 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
 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 +994,Production Orders Created: {0},Framleiðslu Pantanir Búið til: {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +996,Production Orders Created: {0},Framleiðslu Pantanir Búið til: {0}
 DocType: Branch,Branch,Branch
 DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
 DocType: Delivery Trip,Fulfillment User,Uppfylling Notandi
@@ -2620,13 +2689,13 @@
 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 +187,Serial No {0} not found,Serial Nei {0} fannst ekki
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +289,Subscription has been {0},Áskriftin hefur verið {0}
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291,Subscription has been {0},Áskriftin hefur verið {0}
 DocType: Fee Schedule Program,Fee Schedule Program,Gjaldskrá áætlun
 DocType: Fee Schedule Program,Student Batch,Student Hópur
 apps/erpnext/erpnext/utilities/activation.py +119,Make Student,gera Student
 DocType: Supplier Scorecard Scoring Standing,Min Grade,Min Grade
-apps/erpnext/erpnext/projects/doctype/project/project.py +214,You have been invited to collaborate on the project: {0},Þér hefur verið boðið að vinna að verkefninu: {0}
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107,Physician not available on {0},Læknir ekki í boði á {0}
+apps/erpnext/erpnext/projects/doctype/project/project.py +216,You have been invited to collaborate on the project: {0},Þér hefur verið boðið að vinna að verkefninu: {0}
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +135,Physician not available on {0},Læknir ekki í boði á {0}
 DocType: Leave Block List Date,Block Date,Block Dagsetning
 DocType: Crop,Crop,Skera
 DocType: Purchase Receipt,Supplier Delivery Note,Birgir Afhending Ath
@@ -2642,13 +2711,12 @@
 DocType: Fee Schedule,Fee Structure,Gjald Uppbygging
 DocType: Timesheet Detail,Costing Amount,kosta Upphæð
 DocType: Student Admission Program,Application Fee,Umsókn Fee
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +50,Submit Salary Slip,Senda Laun Slip
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52,Submit Salary Slip,Senda Laun Slip
 apps/erpnext/erpnext/controllers/selling_controller.py +136,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: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Landbúnaður Greining Criteria
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +193,Sort by Criteria,Raða eftir viðmiðum
 DocType: POS Profile,[Select],[Veldu]
 DocType: Vital Signs,Blood Pressure (diastolic),Blóðþrýstingur (diastolic)
 DocType: SMS Log,Sent To,send til
@@ -2658,8 +2726,8 @@
 apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,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/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Læknir {0} ekki fáanleg á {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2539,Select Batch No,Veldu lotu nr
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +57,Invalid {0}: {1},Ógild {0}: {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2565,Select Batch No,Veldu lotu nr
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61,Invalid {0}: {1},Ógild {0}: {1}
 ,GSTR-1,GSTR-1
 DocType: Purchase Invoice,PINV-RET-,PINV-RET-
 DocType: Fee Validity,Reference Inv,Tilvísun Inv
@@ -2671,11 +2739,11 @@
 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 +125,No Item with Barcode {0},Ekkert atriði með Strikamerki {0}
+apps/erpnext/erpnext/stock/get_item_details.py +127,No Item with Barcode {0},Ekkert atriði með Strikamerki {0}
 DocType: Normal Test Items,Require Result Value,Krefjast niðurstöður gildi
 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 +517,Boms,Boms
-apps/erpnext/erpnext/stock/doctype/item/item.py +151,Stores,verslanir
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +527,Boms,Boms
+apps/erpnext/erpnext/stock/doctype/item/item.py +161,Stores,verslanir
 DocType: Project Type,Projects Manager,Verkefnisstjóri
 DocType: Serial No,Delivery Time,Afhendingartími
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Öldrun Byggt á
@@ -2686,43 +2754,46 @@
 DocType: Leave Block List,Allow Users,leyfa notendum
 DocType: Purchase Order,Customer Mobile No,Viðskiptavinur Mobile Nei
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Fastir
+DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Upplýsingar um sjóðstreymi fyrir sjóðstreymi
 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 +72,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 +463,Show Salary Slip,Sýna Laun Slip
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +848,Transfer Material,Transfer Efni
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849,Transfer Material,Transfer Efni
 DocType: Fees,Send Payment Request,Senda greiðslubók
 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."
 DocType: Water Analysis,Origin,Uppruni
 apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Þ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 +1142,Please set recurring after saving,Vinsamlegast settu endurtekin eftir vistun
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +756,Select change amount account,Veldu breyting upphæð reiknings
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1154,Please set recurring after saving,Vinsamlegast settu endurtekin eftir vistun
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +767,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
 DocType: Soil Texture,Clay,Leir
 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
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45,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 +77,"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."
+apps/erpnext/erpnext/setup/doctype/company/company.py +78,"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: Cash Flow Mapping,Is Income Tax Liability,Er tekjuskattsskuldbinding
 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: Sales Invoice, Shipping Bill Number,Shipping Bill Number
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,rekjanleiki
 DocType: Asset Maintenance Log,Actions performed,Aðgerðir gerðar
+DocType: Cash Flow Mapper,Section Leader,Kafli Leader
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Uppruni Funds (Skuldir)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +411,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}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418,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: Supplier Scorecard Scoring Standing,Employee,Starfsmaður
 DocType: Asset Repair,Failure Date,Bilunardagur
 DocType: Sample Collection,Collected Time,Safnað tíma
-apps/erpnext/erpnext/config/healthcare.py +134,Test Sample.,Prófunarsýni.
 DocType: Company,Sales Monthly History,Sala mánaðarlega sögu
 DocType: Asset Maintenance Task,Next Due Date,Næsta gjalddagi
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Veldu hópur
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +242,{0} {1} is fully billed,{0} {1} er að fullu innheimt
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} er að fullu innheimt
 apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +47,Vital Signs,Lífsmörk
 DocType: Training Event,End Time,End Time
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Active Laun Uppbygging {0} fannst fyrir starfsmann {1} fyrir gefin dagsetningar
@@ -2731,6 +2802,7 @@
 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/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Ertu viss um að þú viljir hætta við þessa stefnumót?
+DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Hotel Herbergi Verðlagning Pakki
 apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,velta Pipeline
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,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
@@ -2742,53 +2814,54 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,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: POS Profile,Applicable for Users,Gildir fyrir notendur
 DocType: Notification Control,Expense Claim Approved,Expense Krafa Samþykkt
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321,Salary Slip of employee {0} already created for this period,Laun Slip starfsmanns {0} þegar búin á þessu tímabili
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +320,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/operations/install_fixtures.py +155,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/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceDate,PieceDate
 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: Supplier Scorecard,Warn for new Purchase Orders,Varið við nýjar innkaupapantanir
 DocType: Quality Inspection Reading,Reading 9,lestur 9
 DocType: Supplier,Is Frozen,er frosinn
-apps/erpnext/erpnext/stock/utils.py +221,Group node warehouse is not allowed to select for transactions,Group hnút vöruhús er ekki leyft að velja fyrir viðskipti
+apps/erpnext/erpnext/stock/utils.py +224,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: Request for Quotation Supplier,No Quote,Engin tilvitnun
 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 +906,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/accounts/doctype/purchase_invoice/purchase_invoice.js +909,Please specify Company to proceed,Vinsamlegast tilgreinið Company til að halda áfram
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27,Net Change in Accounts Receivable,Net Breyta viðskiptakrafna
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,jöfnunaraðgerðir Off
-DocType: Offer Letter,Accepted,Samþykkt
+DocType: Job Offer,Accepted,Samþykkt
 DocType: Grant Application,Organization,Skipulag
 DocType: BOM Update Tool,BOM Update Tool,BOM Update Tool
 DocType: SG Creation Tool Course,Student Group Name,Student Group Name
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Sýna sprauta skjá
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Búa til gjöld
 apps/erpnext/erpnext/setup/doctype/company/company.js +91,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.
+apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,leitarniðurstöður
 DocType: Room,Room Number,Room Number
-apps/erpnext/erpnext/utilities/transaction_base.py +101,Invalid reference {0} {1},Ógild vísun {0} {1}
+apps/erpnext/erpnext/utilities/transaction_base.py +103,Invalid reference {0} {1},Ógild vísun {0} {1}
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) getur ekki verið meiri en áætlað quanitity ({2}) í framleiðslu Order {3}
 DocType: Shipping Rule,Shipping Rule Label,Sendingar Regla Label
 DocType: Journal Entry Account,Payroll Entry,Launaskrá
 apps/erpnext/erpnext/setup/doctype/company/company.js +35,Make Tax Template,Gerðu skattmálsgrein
 apps/erpnext/erpnext/public/js/conf.js +28,User Forum,User Forum
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +308,Raw Materials cannot be blank.,Hráefni má ekki vera auður.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +485,"Could not update stock, invoice contains drop shipping item.","Gat ekki uppfært lager, reikningsnúmer inniheldur falla skipum hlut."
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +318,Raw Materials cannot be blank.,Hráefni má ekki vera auður.
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +496,"Could not update stock, invoice contains drop shipping item.","Gat ekki uppfært lager, reikningsnúmer inniheldur falla skipum hlut."
 DocType: Lab Test Sample,Lab Test Sample,Lab Test Dæmi
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +492,Quick Journal Entry,Quick Journal Entry
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491,Quick Journal Entry,Quick Journal Entry
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,Þú getur ekki breytt hlutfall ef BOM getið agianst hvaða atriði
 DocType: Restaurant,Invoice Series Prefix,Reiknivél Reiknivél
 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 +205,Please enter Planned Qty for Item {0} at row {1},Vinsamlegast sláðu Planned Magn fyrir lið {0} á röð {1}
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +102,Google Maps integration is not enabled,Samþætting Google korta er ekki virk
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,{0} {1} is not submitted,{0} {1} er ekki lögð
-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/stock/doctype/delivery_trip/delivery_trip.py +101,Google Maps integration is not enabled,Samþætting Google korta er ekki virk
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} er ekki lögð
 DocType: Member,Membership Expiry Date,Félagsdagur
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{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
@@ -2799,34 +2872,38 @@
 apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Nýjasta verð uppfært í öllum BOMs
 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 +424,The following Production Orders were created:,Eftirfarandi Framleiðslu Pantanir voru búnar:
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +446,The following Production Orders were created:,Eftirfarandi Framleiðslu Pantanir voru búnar:
 DocType: Student Admission Program,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 +68,Total Absent,alls Absent
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +840,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 +187,Unit of Measure,Mælieining
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +848,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 +191,Unit of Measure,Mælieining
 DocType: Fiscal Year,Year End Date,Ár Lokadagur
 DocType: Task Depends On,Task Depends On,Verkefni veltur á
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1024,Opportunity,tækifæri
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026,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 +245,{0} {1} is closed,{0} {1} er lokað
+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?
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Samtals safnað: {0}
 DocType: Purchase Receipt,Get Current Stock,Fá núverandi lager
+DocType: Purchase Invoice,ineligible,óhæfur
 apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Tré Bill of Materials
 DocType: Student,Joining Date,Tengja Dagsetning
 ,Employees working on a holiday,Starfsmenn sem vinna í frí
+DocType: Share Balance,Current State,Núverandi staða
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Mark Present
+DocType: Share Transfer,From Shareholder,Frá hluthafa
 DocType: Project,% Complete Method,% Complete Aðferð
 apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Lyf
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,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: Cash Flow Mapping,Is Finance Cost Adjustment,Er fjármálakostnaður aðlögun
 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)
@@ -2837,7 +2914,7 @@
 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
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +10,Assessment Group: ,Námsmat:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14,Assessment Group: ,Námsmat:
 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)
@@ -2845,11 +2922,13 @@
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,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 +794,Please supply the specified items at the best possible rates,Gefðu tilgreind atriði í besta mögulega verð
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796,Please supply the specified items at the best possible rates,Gefðu tilgreind atriði í besta mögulega verð
 DocType: Membership,USD,USD
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Gerðu innheimtu
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80,Remaining Balance,Eftirstöðvar
 DocType: Selling Settings,Auto close Opportunity after 15 days,Auto nálægt Tækifæri eftir 15 daga
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +82,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Innkaupapantanir eru ekki leyfðar fyrir {0} vegna punkta sem standa upp á {1}.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Innkaupapantanir eru ekki leyfðar fyrir {0} vegna punkta sem standa upp á {1}.
+apps/erpnext/erpnext/stock/doctype/item/item.py +497,Barcode {0} is not a valid {1} code,Strikamerki {0} er ekki gilt {1} kóða
 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 +124,Contract End Date must be greater than Date of Joining,Samningur Lokadagur verður að vera hærri en Dagsetning Tengja
@@ -2859,12 +2938,12 @@
 DocType: Delivery Note,DN-,DN-
 apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}",Bæði &quot;læknaráætlun&quot; og tími fyrir hvert skipun &quot;verður að vera stillt fyrir Dr {0}
 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 +374,{0} against Purchase Order {1},{0} gegn Purchase Order {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} gegn Purchase Order {1}
 DocType: Patient,Patient Demographics,Lýðfræðilegar upplýsingar um sjúklinga
 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
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +226,Total advance amount cannot be greater than total claimed amount,Samtals fyrirfram upphæð getur ekki verið hærri en heildarfjölda krafna
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +210,Total advance amount cannot be greater than total claimed amount,Samtals fyrirfram upphæð getur ekki verið hærri en heildarfjölda krafna
 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
@@ -2892,9 +2971,11 @@
 DocType: Purchase Receipt Item,Recd Quantity,Recd Magn
 apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Fee Records Búið - {0}
 DocType: Asset Category Account,Asset Category Account,Asset Flokkur Reikningur
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteNum,CompteNum
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Geta ekki framleitt meira ítarefni {0} en Sales Order Magn {1}
-apps/erpnext/erpnext/stock/doctype/item/item.js +360,Select Attribute Values,Veldu Eiginleikar
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +537,Stock Entry {0} is not submitted,Stock Entry {0} er ekki lögð
+apps/erpnext/erpnext/stock/doctype/item/item.js +362,Select Attribute Values,Veldu Eiginleikar
+DocType: Purchase Invoice,Reason For Issuing document,Ástæða fyrir útgáfu skjals
+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 +45,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
@@ -2905,9 +2986,12 @@
 apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","td Bank, Cash, Credit Card"
 DocType: Lead Source,Source Name,Source Name
 DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","Venjulegur hvíldarþrýstingur hjá fullorðnum er u.þ.b. 120 mmHg slagbilsþrýstingur og 80 mmHg díastólskur, skammstafað &quot;120/80 mmHg&quot;"
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Stilla hluti geymsluþol á dögum, til að stilla gildistíma byggt á framleiðslu_date auk sjálfs lífs"
 DocType: Journal Entry,Credit Note,Inneignarnótu
+DocType: Projects Settings,Ignore Employee Time Overlap,Hunsa starfsmannatímabilið
 DocType: Warranty Claim,Service Address,þjónusta Address
 DocType: Asset Maintenance Task,Calibration,Kvörðun
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,{0} is a company holiday,{0} er félagsfrí
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Húsgögnum og innréttingum
 DocType: Item,Manufacture,Framleiðsla
 apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Uppsetningarfyrirtæki
@@ -2939,7 +3023,7 @@
 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 +120,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 +241,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
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +247,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: Supplier Scorecard Criteria,Criteria Weight,Viðmiðunarþyngd
 DocType: Buying Settings,Default Buying Price List,Sjálfgefið Buying Verðskrá
 DocType: Payroll Entry,Salary Slip Based on Timesheet,Laun Slip Byggt á tímaskráningar
@@ -2947,7 +3031,7 @@
 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 +160,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
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +240,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: Hub Category,Parent Category,Foreldraflokkur
 DocType: Payroll Entry,Select Employees,Select Starfsmenn
 DocType: Opportunity,Potential Sales Deal,Hugsanleg sala Deal
@@ -2956,7 +3040,6 @@
 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 +79,Ledger,Ledger
 DocType: Patient Medical Record,PMR-,PMR-
@@ -2965,6 +3048,7 @@
 DocType: POS Profile,Print Format for Online,Prenta snið fyrir á netinu
 DocType: Shopping Cart Settings,Shopping Cart Settings,Shopping Cart Stillingar
 DocType: Journal Entry,Accounting Entries,Bókhalds Færslur
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, 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 valin verðlagning er gerð fyrir &#39;Rate&#39; mun hún skrifa yfir Verðskrá. Verðlagning Regluhlutfall er endanlegt hlutfall, þannig að ekki skal nota frekari afslátt. Þess vegna, í viðskiptum eins og söluskilningi, innkaupapöntun o.þ.h., verður það sótt í &#39;Rate&#39; reitinn, frekar en &#39;Verðskrárhlutfall&#39; reitinn."
 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}
 DocType: Journal Entry Account,Reference Due Date,Tilvísunardagsetning
 DocType: Purchase Order,Ref SQ,Ref SQ
@@ -2986,15 +3070,17 @@
 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
 DocType: Volunteer Skill,Volunteer Skill,Sjálfboðaliðastarf
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +736,Please select an item in the cart,Vinsamlegast veldu hlut í körfu
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +780,Please select an item in the cart,Vinsamlegast veldu hlut í körfu
 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/operations/install_fixtures.py +74,Arrear,Arrear
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,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 +43,Disabled template must not be default template,Óvirkt sniðmát má ekki vera sjálfgefið sniðmát
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +313,For row {0}: Enter planned qty,Fyrir röð {0}: Sláðu inn skipulagt magn
+DocType: Shareholder,SH-,SH-
 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 +823,Delivery,Afhending
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825,Delivery,Afhending
 DocType: Volunteer,Weekdays,Virka daga
 DocType: Stock Reconciliation Item,Current Qty,Núverandi Magn
 DocType: Restaurant Menu,Restaurant Menu,Veitingahús Valmynd
@@ -3002,16 +3088,17 @@
 DocType: Appraisal Goal,Key Responsibility Area,Key Ábyrgð Area
 apps/erpnext/erpnext/utilities/activation.py +127,"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
-apps/erpnext/erpnext/setup/doctype/company/company.py +147,Set default inventory account for perpetual inventory,Stilltu sjálfgefinn birgðareikning fyrir varanlegan birgða
+apps/erpnext/erpnext/setup/doctype/company/company.py +151,Set default inventory account for perpetual inventory,Stilltu sjálfgefinn birgðareikning fyrir varanlegan birgða
 DocType: Item Reorder,Material Request Type,Efni Beiðni Type
 apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accural Journal Entry fyrir laun frá {0} til {1}
 apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Senda Grant Review Email
-apps/erpnext/erpnext/accounts/page/pos/pos.js +840,"LocalStorage is full, did not save","LocalStorage er fullt, ekki spara"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +95,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM viðskipta Factor er nauðsynlegur
+apps/erpnext/erpnext/accounts/page/pos/pos.js +848,"LocalStorage is full, did not save","LocalStorage er fullt, ekki spara"
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,Row {0}: UOM Conversion Factor is mandatory,Row {0}: UOM viðskipta Factor er nauðsynlegur
 apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Herbergi getu
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +14,Ref,Ref
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +85,Ref,Ref
 DocType: Lab Test,LP-,LP-
 DocType: Healthcare Settings,Registration Fee,Skráningargjald
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vinsamlegast settu Nöfnunarröð fyrir {0} í gegnum Skipulag&gt; Stillingar&gt; Nöfnunarröð
 DocType: Budget,Cost Center,kostnaður Center
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,Voucher #,skírteini #
 DocType: Notification Control,Purchase Order Message,Purchase Order skilaboð
@@ -3024,22 +3111,24 @@
 DocType: Employee Education,Class / Percentage,Flokkur / Hlutfall
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Forstöðumaður markaðssetning og sala
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Tekjuskattur
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","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.
 apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Farðu í Letterheads
 DocType: Item Supplier,Item Supplier,Liður Birgir
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1243,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 +874,Please select a value for {0} quotation_to {1},Vinsamlegast veldu gildi fyrir {0} quotation_to {1}
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1255,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 +876,Please select a value for {0} quotation_to {1},Vinsamlegast veldu gildi fyrir {0} quotation_to {1}
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414,No Items selected for transfer,Engar atriði valdir til flutnings
 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 +183,"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 +123,Gain/Loss on Asset Disposal,Hagnaður / tap Asset förgun
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Reikningsnúmer fyrir reikning {0} er ekki tiltækt. <br> Vinsamlegast settu upp reikningsskýrsluna þína rétt.
 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: Normal Test Items,Result Value,Niðurstaða gildi
+DocType: Hotel Room,Hotels,Hótel
 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
@@ -3050,6 +3139,7 @@
 DocType: Purchase Invoice,Taxes and Charges Deducted,Skattar og gjöld FrÃ¡
 apps/erpnext/erpnext/hooks.py +142,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}
+apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Áminning um að uppfæra GSTIN Sent
 DocType: Sales Invoice,Debit To,debet Til
 DocType: Restaurant Menu Item,Restaurant Menu Item,Veitingahús Valmynd Item
 DocType: Delivery Note,Required only for sample item.,Aðeins nauðsynlegt fyrir sýnishorn hlut.
@@ -3057,31 +3147,33 @@
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,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/education/doctype/student_admission/student_admission.py +35,Student Admissions,Student Innlagnir
-apps/erpnext/erpnext/accounts/party.py +376,{0} {1} is disabled,{0} {1} er óvirk
+apps/erpnext/erpnext/accounts/party.py +389,{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/operations/install_fixtures.py +200,Extra Large,Auka stór
 DocType: Crop,Scientific Name,Vísindalegt nafn
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Samtals Leaves
+DocType: Customer,"Reselect, if the chosen contact is edited after save","Veldu aftur, ef valinn tengiliður er breytt eftir að vista"
 DocType: Consultation,In print,Í prenti
 ,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 +540,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/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/utilities/user_progress_utils.py +66,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/operations/install_fixtures.py +199,Large,stór
 DocType: Homepage Featured Product,Homepage Featured Product,Heimasíðan Valin Vara
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +246,All Assessment Groups,Allir Námsmat Hópar
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +247,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 +233,Total {0} ({1}),Alls {0} ({1})
+apps/erpnext/erpnext/accounts/report/financial_statements.py +257,Total {0} ({1}),Alls {0} ({1})
 DocType: C-Form Invoice Detail,Territory,Territory
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Vinsamlegast nefna engin heimsókna krafist
 DocType: Stock Settings,Default Valuation Method,Sjálfgefið Verðmatsaðferð
 apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Gjald
 apps/erpnext/erpnext/setup/doctype/company/company.js +154,Update in progress. It might take a while.,Uppfærsla í gangi. Það gæti tekið smá stund.
+DocType: Production Plan Item,Produced Qty,Framleitt magn
 DocType: Vehicle Log,Fuel Qty,eldsneyti Magn
 DocType: Production Order Operation,Planned Start Time,Planned Start Time
 DocType: Course,Assessment,mat
@@ -3092,8 +3184,9 @@
 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 +159,Quotation {0} is cancelled,Tilvitnun {0} er hætt
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Outstanding Amount,Heildarstöðu útistandandi
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +106,Total Outstanding Amount,Heildarstöðu útistandandi
 DocType: Sales Partner,Targets,markmið
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54,Please register the SIREN number in the company information file,Vinsamlegast skráðu SIREN númerið í upplýsingaskránni
 DocType: Price List,Price List Master,Verðskrá Master
 DocType: GST Account,CESS Account,CESS reikning
 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ð.
@@ -3102,7 +3195,6 @@
 apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Veldu sjúkling
 DocType: Price List,Applicable for Countries,Gildir fyrir löndum
 DocType: Supplier Scorecard Scoring Variable,Parameter Name,Parameter Name
-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/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,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.
@@ -3132,15 +3224,16 @@
 DocType: Agriculture Task,Ignore holidays,Hunsa frí
 apps/erpnext/erpnext/controllers/stock_controller.py +233,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/projects/doctype/timesheet/timesheet.py +340,Invoice already created for all billing hours,Reikningur er þegar búinn til fyrir alla reikningstíma
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Nafn villa: {0}
-apps/erpnext/erpnext/stock/doctype/item/item_list.js +12,Shortage,skortur
+DocType: Cash Flow Mapping,Is Finance Cost,Er fjármagnskostnaður
 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)
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Vinsamlegast stilltu sjálfgefinn viðskiptavin í veitingastaðnum
 ,Salary Register,laun Register
 DocType: Warehouse,Parent Warehouse,Parent Warehouse
 DocType: C-Form Invoice Detail,Net Total,Net Total
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +527,Default BOM not found for Item {0} and Project {1},Sjálfgefið BOM fannst ekki fyrir lið {0} og verkefni {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +546,Default BOM not found for Item {0} and Project {1},Sjálfgefið BOM fannst ekki fyrir lið {0} og verkefni {1}
 apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Skilgreina ýmsar tegundir lána
 DocType: Bin,FCFS Rate,FCFS Rate
 DocType: Opening Invoice Creation Tool Item,Outstanding Amount,útistandandi fjárhæð
@@ -3153,10 +3246,11 @@
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Kostnaður og á
 DocType: Healthcare Settings,Out Patient Settings,Úthreinsun sjúklinga
 DocType: Account,Round Off,umferð Off
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +252,Quantity must be positive,Magn verður að vera jákvætt
-,Requested Qty,Umbeðin Magn
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259,Quantity must be positive,Magn verður að vera jákvætt
+DocType: Material Request Plan Item,Requested Qty,Umbeðin Magn
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96,The fields From Shareholder and To Shareholder cannot be blank,Reitirnir frá hluthafa og hluthöfum geta ekki verið auður
 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}
+apps/erpnext/erpnext/controllers/item_variant.py +98,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}
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Veldu raðnúmer
 DocType: BOM Item,Scrap %,rusl%
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Gjöld verður dreift hlutfallslega miðað hlut Fjöldi eða magn, eins og á val þitt"
@@ -3175,9 +3269,9 @@
 DocType: Employee Loan,Repaid/Closed,Launað / Lokað
 DocType: Item,Total Projected Qty,Alls spáð Magn
 DocType: Monthly Distribution,Distribution Name,Dreifing Name
-apps/erpnext/erpnext/stock/stock_ledger.py +471,"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 zero valuation rate 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ðmatshlutfall fannst ekki fyrir lið {0}, sem þarf til að gera bókhaldslegar færslur fyrir {1} {2}. Ef hluturinn er í viðskiptum sem núllmatshlutfall í {1} skaltu nefna það í {1} hlutatöflunni. Annars skaltu vinsamlegast stofna viðskipti í viðskiptum fyrir vöruna eða nefna verðmat í hlutaskránni og reyndu síðan að senda inn / aftaka þessa færslu"
+apps/erpnext/erpnext/stock/stock_ledger.py +477,"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 zero valuation rate 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ðmatshlutfall fannst ekki fyrir lið {0}, sem þarf til að gera bókhaldslegar færslur fyrir {1} {2}. Ef hluturinn er í viðskiptum sem núllmatshlutfall í {1} skaltu nefna það í {1} hlutatöflunni. Annars skaltu vinsamlegast stofna viðskipti í viðskiptum fyrir vöruna eða nefna verðmat í hlutaskránni og reyndu síðan að senda inn / aftaka þessa færslu"
 DocType: Course,Course Code,Auðvitað Code
-apps/erpnext/erpnext/controllers/stock_controller.py +331,Quality Inspection required for Item {0},Quality Inspection krafist fyrir lið {0}
+apps/erpnext/erpnext/controllers/stock_controller.py +337,Quality Inspection required for Item {0},Quality Inspection krafist fyrir lið {0}
 DocType: POS Settings,Use POS in Offline Mode,Notaðu POS í ótengdu ham
 DocType: Supplier Scorecard,Supplier Variables,Birgir Variables
 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
@@ -3186,6 +3280,7 @@
 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
+DocType: Cash Flow Mapper,Section Subtotal,Hluti undirliða
 apps/erpnext/erpnext/accounts/page/pos/pos.js +498,Please select Apply Discount On,Vinsamlegast veldu Virkja afsláttur á
 DocType: Stock Settings,Sample Retention Warehouse,Sýnishorn vörugeymsla
 DocType: Company,Default Receivable Account,Sjálfgefið Krafa Reikningur
@@ -3199,13 +3294,15 @@
 apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61,You have already assessed for the assessment criteria {}.,Þú hefur nú þegar metið mat á viðmiðunum {}.
 DocType: Vehicle Service,Engine Oil,Vélarolía
 DocType: Sales Invoice,Sales Team1,velta TEAM1
-apps/erpnext/erpnext/stock/doctype/item/item.py +521,Item {0} does not exist,Liður {0} er ekki til
+apps/erpnext/erpnext/stock/doctype/item/item.py +546,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
 DocType: Company,Default Inventory Account,Sjálfgefin birgðareikningur
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192,The folio numbers are not matching,Folio númerin passa ekki saman
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Row {0}: Lokið Magn verður að vera hærri en núll.
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +249,Payment Request for {0},Greiðslubók um {0}
+DocType: Item Barcode,Barcode Type,Strikamerki
 DocType: Antibiotic,Antibiotic Name,Name Sýklalyf
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Vörunúmer&gt; Liðurhópur&gt; Vörumerki
 DocType: Purchase Invoice,Apply Additional Discount On,Berið Viðbótarupplýsingar afsláttur á
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Veldu tegund ...
 DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,Tengill til allra landsdeilda þar sem skógurinn er að vaxa
@@ -3216,7 +3313,7 @@
 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 +160,Target warehouse is mandatory for row {0},Target vöruhús er nauðsynlegur fyrir röð {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +164,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 +397,Add Employees,Bæta Starfsmenn
@@ -3224,20 +3321,19 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,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 +805,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/stock/doctype/material_request/material_request.js +806,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/data/industry_type.py +29,"Food, Beverage & Tobacco","Matur, drykkir og Tobacco"
 DocType: Account,Account Number,Reikningsnúmer
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +714,Can only make payment against unbilled {0},Getur aðeins gera greiðslu gegn ógreitt {0}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +720,Can only make payment against unbilled {0},Getur aðeins gera greiðslu gegn ógreitt {0}
 apps/erpnext/erpnext/controllers/selling_controller.py +101,Commission rate cannot be greater than 100,hlutfall Framkvæmdastjórnin getur ekki verið meiri en 100
 DocType: Volunteer,Volunteer,Sjálfboðaliði
 DocType: Stock Entry,Subcontract,undirverktaka
-apps/erpnext/erpnext/public/js/utils/party.js +165,Please enter {0} first,Vinsamlegast sláðu inn {0} fyrst
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +87,No replies from,Engin svör frá
+apps/erpnext/erpnext/public/js/utils/party.js +166,Please enter {0} first,Vinsamlegast sláðu inn {0} fyrst
+apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,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
@@ -3250,6 +3346,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,hugbúnaður
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Colour
 DocType: Assessment Plan Criteria,Assessment Plan Criteria,Mat Plan Viðmið
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +118,Expiry date is mandatory for selected item,Upphafsdagur er nauðsynlegur fyrir valið atriði
 DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Hindra innkaupapantanir
 apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,Viðkvæm
 DocType: Patient Appointment,Scheduled,áætlunarferðir
@@ -3258,7 +3355,7 @@
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Veldu viðskiptavini
 DocType: Student Log,Academic,Academic
 DocType: Patient,Personal and Social History,Persónuleg og félagsleg saga
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +52,User {0} created,Notandi {0} búinn til
+apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,User {0} created,Notandi {0} búinn til
 DocType: Fee Schedule,Fee Breakup for each student,Gjaldskrá fyrir hverja nemanda
 apps/erpnext/erpnext/controllers/accounts_controller.py +540,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.
@@ -3266,12 +3363,12 @@
 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 +386,Price List Currency not selected,Verðlisti Gjaldmiðill ekki valinn
+apps/erpnext/erpnext/stock/get_item_details.py +388,Price List Currency not selected,Verðlisti Gjaldmiðill ekki valinn
+DocType: Purchase Invoice,Availed ITC Cess,Notaði ITC Cess
 ,Student Monthly Attendance Sheet,Student Monthly Aðsókn Sheet
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Sendingarregla gildir aðeins um sölu
-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 +5,Until,þangað
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +13,Until,þangað
 DocType: Rename Tool,Rename Log,endurnefna Innskráning
 apps/erpnext/erpnext/education/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
@@ -3283,10 +3380,9 @@
 DocType: Fee Validity,Visited yet,Heimsóknir ennþá
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,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/non_profit/doctype/member/member_dashboard.py +6,Memeber Activity,Memeber Activity
 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 +117,Add Students,Bæta Nemendur
-apps/erpnext/erpnext/public/js/utils.js +264,Please select {0},Vinsamlegast veldu {0}
+apps/erpnext/erpnext/public/js/utils.js +270,Please select {0},Vinsamlegast veldu {0}
 DocType: C-Form,C-Form No,C-Form Nei
 DocType: BOM,Exploded_items,Exploded_items
 apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,Skráðu vörur þínar eða þjónustu sem þú kaupir eða selur.
@@ -3301,38 +3397,39 @@
 DocType: Student,Exit,Hætta
 apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Root Type er nauðsynlegur
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Mistókst að setja upp forstillingar
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} er nú með {1} Birgir Stuðningskort og RFQs til þessa birgja skal gefa út með varúð.
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} er nú með {1} Birgir Stuðningskort og RFQs til þessa birgja skal gefa út með varúð.
 DocType: Chapter,Non Profit Manager,Non Profit Manager
 DocType: BOM,Total Cost(Company Currency),Total Cost (Company Gjaldmiðill)
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,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
-apps/erpnext/erpnext/accounts/report/financial_statements.py +152,Could not retrieve information for {0}.,Gat ekki sótt upplýsingar um {0}.
+apps/erpnext/erpnext/accounts/report/financial_statements.py +172,Could not retrieve information for {0}.,Gat ekki sótt upplýsingar um {0}.
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134,Opening Entry Journal,Opnun dagbókar
 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: Healthcare Settings,Result Printed,Niðurstaða prentuð
 DocType: Asset Category Account,Depreciation Expense Account,Afskriftir kostnað reiknings
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Probationary Period,reynslutíma
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Probationary Period,reynslutíma
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Skoða {0}
 DocType: Customer Group,Only leaf nodes are allowed in transaction,Aðeins blaða hnútar mega í viðskiptum
 DocType: Project,Total Costing Amount (via Timesheets),Samtals kostnaðarverð (með tímariti)
 DocType: Employee Advance,Expense Approver,Expense samþykkjari
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +134,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/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 +89,Non-Group to Group,Non-Group til Group
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,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
 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 +97,Printed On,Prentað á
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +204,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: Patient Appointment,Reminded,Minntist á
 DocType: Patient,PID-,PID-
 DocType: Chapter Member,Chapter Member,Kafli meðlimur
+DocType: Material Request Plan Item,Minimum Order Quantity,lágmarks magn pöntunar
 apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Stofnunin þín
 DocType: Fee Component,Fees Category,Gjald Flokkur
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Vinsamlegast sláðu létta dagsetningu.
@@ -3345,7 +3442,7 @@
 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 +350,Item Price updated for {0} in Price List {1},Item Verð uppfærð fyrir {0} í verðskrá {1}
+apps/erpnext/erpnext/stock/get_item_details.py +352,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 +128,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
@@ -3356,13 +3453,14 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,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 +515,[Error],[Villa]
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516,[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
 apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Vinsamlegast veldu Lokadagsetning fyrir lokið viðgerð
 DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Student Hópur Aðsókn Tool
 apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,Limit Crossed
 apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Áætlað Upto
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Viðskiptavinur&gt; Viðskiptavinahópur&gt; Territory
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Venture Capital
 apps/erpnext/erpnext/education/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.
 DocType: UOM,Must be Whole Number,Verður að vera heil tala
@@ -3376,9 +3474,9 @@
 DocType: Shopping Cart Settings,Orders,pantanir
 DocType: Employee Leave Approver,Leave Approver,Skildu samþykkjari
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,Vinsamlegast veldu lotu
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalLib,JournalLib
 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
@@ -3391,34 +3489,30 @@
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Tímabil Lokar Entry
 apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Veldu deild ...
 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 +361,Amount {0} {1} {2} {3},Upphæð {0} {1} {2} {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +367,Amount {0} {1} {2} {3},Upphæð {0} {1} {2} {3}
 DocType: Account,Depreciation,gengislækkun
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102,The number of shares and the share numbers are inconsistent,Fjöldi hluta og hlutanúmer eru ósamræmi
 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
 apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Meðaltal Selja Verðskrá Rate
-DocType: Production Plan Sales Order,Salse Order Date,Salse Röð Dagsetning
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Birgir&gt; Birgir Tegund
 DocType: Salary Component,Salary Component,laun Component
 apps/erpnext/erpnext/accounts/utils.py +495,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
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +195,Most Popular,Vinsælast
 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 +550,Material Requests {0} created,Efni Beiðnir {0} búnar
 DocType: Restaurant Reservation,No of People,Ekkert fólk
-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 +276,Stock cannot be updated against Purchase Receipt {0},Stock Ekki er hægt að uppfæra á móti kvittun {0}
-DocType: Company,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 +320,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/accounts/party.py +318,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/education/doctype/program/program.js +8,Student Applicant,Student Umsækjandi
 DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,Upprunalega fyrir viðtakanda
 DocType: Asset Category Account,Accumulated Depreciation Account,Uppsöfnuðum afskriftum Reikningur
@@ -3430,26 +3524,26 @@
 DocType: Activity Cost,Billing Rate,Innheimta Rate
 ,Qty to Deliver,Magn í Bera
 ,Stock Analytics,lager Analytics
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +508,Operations cannot be left blank,Aðgerðir geta ekki vera autt
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +518,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 +99,Party Type is mandatory,Party Type er nauðsynlegur
+apps/erpnext/erpnext/regional/france/utils.py +30,Deletion is not permitted for country {0},Eyðing er ekki leyfð fyrir land {0}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +105,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 +414,{0} {1} is cancelled or closed,{0} {1} er aflýst eða lokaður
 DocType: Asset,Calculate Depreciation,Reikna afskriftir
 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
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35,Net Cash from Investing,Handbært fé frá fjárfesta
 DocType: Production Order,Work-in-Progress Warehouse,Work-í-gangi Warehouse
 apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,Eignastýring {0} Leggja skal fram
 DocType: Fee Schedule Program,Total Students,Samtals nemendur
 apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,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 +352,Reference #{0} dated {1},Tilvísun # {0} dagsett {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 +164,Depreciation Eliminated due to disposal of assets,Afskriftir Féll út vegna ráðstöfunar eigna
 DocType: Member,Member,Meðlimur
 apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,stjórna Heimilisföng
 DocType: Pricing Rule,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/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Veldu nemendur handvirkt fyrir hópinn sem byggir á starfsemi
 DocType: Journal Entry,User Remark,Notandi Athugasemd
@@ -3458,7 +3552,7 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},Greiddur Upphæð má ekki vera meiri en heildar neikvæð útistandandi {0}
 DocType: Supplier Scorecard Period,Variables,Variables
 DocType: Employee Internal Work History,Employee Internal Work History,Starfsmaður Innri Vinna Saga
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +246,Closing (Dr),Lokun (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249,Closing (Dr),Lokun (Dr)
 DocType: Cheque Print Template,Cheque Size,ávísun Size
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,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.
@@ -3469,12 +3563,12 @@
 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/assets/doctype/asset/asset.py +56,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: Share Transfer,(including),(þ.mt)
 DocType: Asset,Double Declining Balance,Tvöfaldur Minnkandi Balance
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Lokað þess geta ekki verið lokað. Unclose að hætta.
 DocType: Student Guardian,Father,faðir
@@ -3483,28 +3577,30 @@
 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/stock/doctype/item/item.js +366,Select at least one value from each of the attributes.,Veldu að minnsta kosti eitt gildi af hverju eiginleiki.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +162,Material Request {0} is cancelled or stopped,Efni Beiðni {0} er aflýst eða henni hætt
+apps/erpnext/erpnext/stock/doctype/item/item.js +368,Select at least one value from each of the attributes.,Veldu að minnsta kosti eitt gildi af hverju eiginleiki.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166,Material Request {0} is cancelled or stopped,Efni Beiðni {0} er aflýst eða henni hætt
 apps/erpnext/erpnext/config/hr.py +310,Leave Management,Skildu Stjórnun
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Group eftir reikningi
+apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21,Please select Employee,Vinsamlegast veldu Starfsmaður
 DocType: Sales Order,Fully Delivered,Alveg Skilað
 DocType: Lead,Lower Income,neðri Tekjur
 DocType: Restaurant Order Entry,Current Order,Núverandi röð
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +179,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_entry/stock_entry.py +183,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 +243,"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/utilities/user_progress.py +173,Go to Programs,Fara í forrit
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +219,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Rú {0} # Úthlutað magn {1} getur ekki verið hærra en óunnið magn {2}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +203,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},Rú {0} # Úthlutað magn {1} getur ekki verið hærra en óunnið magn {2}
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Innkaupapöntunarnúmeri þarf fyrir lið {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +943,Production Order not created,Framleiðsla Order ekki búin
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +945,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/education/doctype/student_applicant/student_applicant.py +39,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
+DocType: Item Barcode,UPC-A,UPC-A
 ,Stock Projected Qty,Stock Áætlaðar Magn
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +431,Customer {0} does not belong to project {1},Viðskiptavinur {0} ekki tilheyra verkefninu {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +442,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 +73,"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
+DocType: Sales Invoice,Customer's Purchase Order,Viðskiptavinar Purchase Order
 DocType: Consultation,Patient,Sjúklingur
 apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Bannað lánshæfiseinkunn á söluskilningi
 DocType: Land Unit,Check if it is a hydroponic unit,Athugaðu hvort það sé vatnsheld eining
@@ -3515,7 +3611,7 @@
 DocType: Supplier Scorecard Period,Calculations,Útreikningar
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Gildi eða Magn
 DocType: Payment Terms Template,Payment Terms,Greiðsluskilmála
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +426,Productions Orders cannot be raised for:,Productions Pantanir geta ekki hækkað um:
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +448,Productions Orders cannot be raised for:,Productions Pantanir geta ekki hækkað um:
 apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minute
 DocType: Purchase Invoice,Purchase Taxes and Charges,Purchase skatta og gjöld
 DocType: Chapter,Meetup Embed HTML,Meetup Fella HTML inn
@@ -3531,7 +3627,7 @@
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Allar Birgir ferðalaga
 DocType: Donor,Donor,Gjafa
 DocType: Global Defaults,Disable In Words,Slökkva á í orðum
-apps/erpnext/erpnext/stock/doctype/item/item.py +49,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/stock/doctype/item/item.py +59,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 +98,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ð
@@ -3542,8 +3638,8 @@
 DocType: Patient,Patient ID,Patient ID
 DocType: Physician Schedule,Schedule Name,Stundaskrá Nafn
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Gera Laun Slip
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +838,Add All Suppliers,Bæta við öllum birgjum
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +83,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Úthlutað Magn má ekki vera hærra en útistandandi upphæð.
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840,Add All Suppliers,Bæta við öllum birgjum
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +89,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Row # {0}: Úthlutað Magn má ekki vera hærra en útistandandi upphæð.
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Fletta BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Veðlán
 DocType: Purchase Invoice,Edit Posting Date and Time,Edit Staða Dagsetning og tími
@@ -3557,12 +3653,12 @@
 apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,eftir
 DocType: Appraisal,Appraisal,Úttekt
 DocType: Purchase Invoice,GST Details,GST upplýsingar
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,Email sent to supplier {0},Tölvupóstur sendur á birgi {0}
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,Email sent to supplier {0},Tölvupóstur sendur á birgi {0}
 DocType: Item,Default Sales Unit of Measure,Sjálfgefin sölustuðull
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Academic Year: ,Námsár:
 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}
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Búðu til gjöld
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Total Kaup Kostnaður (í gegnum kaupa Reikningar)
 DocType: Training Event,Start Time,Byrjunartími
@@ -3571,30 +3667,32 @@
 DocType: Patient Appointment,Patient Appointment,Sjúklingaráð
 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 +64,Unsubscribe from this Email Digest,Segja upp áskrift að þessum tölvupósti Digest
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +828,Get Suppliers By,Fáðu birgja eftir
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +170,{0} not found for Item {1},{0} fannst ekki fyrir lið {1}
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830,Get Suppliers By,Fáðu birgja eftir
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +172,{0} not found for Item {1},{0} fannst ekki fyrir lið {1}
 apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Fara í námskeið
 DocType: Accounts Settings,Show Inclusive Tax In Print,Sýna innifalið skatt í prenti
+apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory","Bankareikningur, Frá Dagsetning og Dagsetning er skylt"
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,skilaboð send
 apps/erpnext/erpnext/accounts/doctype/account/account.py +98,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)
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +229,Total advance amount cannot be greater than total sanctioned amount,Heildarfjöldi fyrirframgreiðslna má ekki vera hærri en heildarfjárhæðir
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +213,Total advance amount cannot be greater than total sanctioned amount,Heildarfjöldi fyrirframgreiðslna má ekki vera hærri en heildarfjárhæðir
 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 +37,Account {0} does not exists,Reikningur {0} er ekki til
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41,Account {0} does not exists,Reikningur {0} er ekki til
 DocType: Project,Project Type,Project Type
 apps/erpnext/erpnext/projects/doctype/task/task.py +142,Child Task exists for this Task. You can not delete this Task.,Barnaskipti er til fyrir þetta verkefni. Þú getur ekki eytt þessu verkefni.
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,DateLet,DateLet
 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/hub_node/page/hub/hub.js +731,No more results,Engar niðurstöður ennþá
 apps/erpnext/erpnext/config/projects.py +51,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 +155,Source and target warehouse must be different,Uppspretta og miða vöruhús verður að vera öðruvísi
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163,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: BOM,Inspection Required,skoðun Required
 DocType: Purchase Invoice Item,PR Detail,PR Detail
 DocType: Driving License Category,Class,Flokkur
 DocType: Sales Order,Fully Billed,Alveg Billed
@@ -3615,7 +3713,6 @@
 DocType: Cheque Print Template,Cheque Height,ávísun Hæð
 DocType: Supplier,Supplier Details,birgir Upplýsingar
 DocType: Setup Progress,Setup Progress,Uppsetning framfarir
-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 +35,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/operations/install_fixtures.py +182,Wire Transfer,millifærsla
@@ -3628,9 +3725,11 @@
 DocType: Lab Test Template,Change In Item,Breyta í lið
 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/accounts/report/general_ledger/general_ledger.py +338,Balance ({0}),Jafnvægi ({0})
 apps/erpnext/erpnext/config/accounts.py +134,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
+apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,Email Áminningar verða sendar öllum aðilum með tengiliðum í tölvupósti
 DocType: Patient,A Negative,Neikvætt
 apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Ekkert meira að sýna.
 DocType: Lead,From Customer,frá viðskiptavinar
@@ -3649,13 +3748,14 @@
 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/healthcare/doctype/patient/patient.js +86,Please save the patient first,Vinsamlegast vista sjúklinginn fyrst
 apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,Aðsókn hefur verið merkt með góðum árangri.
 DocType: Program Enrollment,Public Transport,Almenningssamgöngur
 DocType: Soil Texture,Silt Composition (%),Silt Samsetning (%)
 DocType: Journal Entry,Remark,athugasemd
 DocType: Healthcare Settings,Avoid Confirmation,Forðastu staðfestingu
 DocType: Purchase Receipt Item,Rate and Amount,Hlutfall og Magn
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +165,Account Type for {0} must be {1},Reikningur Type fyrir {0} verður að vera {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +171,Account Type for {0} must be {1},Reikningur Type fyrir {0} verður að vera {1}
 DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Sjálfgefin tekjureikningur til notkunar ef hann er ekki í lækni til að bóka samráðsgjöld.
 apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Blöð og Holiday
 DocType: Education Settings,Current Academic Term,Núverandi námsbraut
@@ -3663,38 +3763,38 @@
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Bæði Warehouse að tilheyra sama Company
 apps/erpnext/erpnext/public/js/templates/contact_list.html +34,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
+,Item Balance (Simple),Varajöfnuður (Einföld)
 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/accounts/report/accounts_receivable/accounts_receivable.html +89,Debit Note Amt,Greiðslubréf Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +196,Debit Note Amt,Greiðslubréf Amt
 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/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Mistókst að stilla sjálfgefið
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Tengsl Guardian1
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +797,Please select BOM against item {0},Vinsamlegast veldu BOM gegn hlut {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +787,Please select BOM against item {0},Vinsamlegast veldu BOM gegn hlut {0}
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Gerðu reikninga
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Handbært fé frá rekstri
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Cash from Operations,Handbært fé frá rekstri
 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 +30,Sub-contracting,Sub-samningagerð
 DocType: Journal Entry Account,Journal Entry Account,Journal Entry Reikningur
 apps/erpnext/erpnext/education/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 +56,"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/setup/doctype/item_group/item_group.py +57,"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
 DocType: Soil Analysis Criteria,Soil Analysis Criteria,Jarðgreiningarmörk
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2021,Please select customer,Vinsamlegast veldu viðskiptavin
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2039,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: Production Plan Sales Order,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/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Viðskiptavinur {0} er búinn til.
 DocType: Stock Settings,Limit Percent,Limit Percent
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Vinsamlegast skipulag kennari Nafnakerfi í menntun&gt; Menntun
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,Eins og er ekki birgðir í boði á hvaða vöruhúsi
 ,Payment Period Based On Invoice Date,Greiðsla Tímabil Byggt á reikningi Dagsetning
 DocType: Sample Collection,No. of print,Fjöldi prenta
+DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Hotel Herbergi pöntunartilboð
 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
@@ -3703,22 +3803,26 @@
 DocType: C-Form,C-FORM-,C-FORM-
 DocType: Vehicle,Insurance Details,Tryggingar Upplýsingar
 DocType: Account,Payable,greiðist
+DocType: Share Balance,Share Type,Deila Tegund
 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 +375,Debtors ({0}),Skuldarar ({0})
+apps/erpnext/erpnext/shopping_cart/cart.py +378,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 +74,Gross Profit %,Framlegð%
 DocType: Appraisal Goal,Weightage (%),Weightage (%)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +496,Change POS Profile,Breyta POS Profile
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +499,Change POS Profile,Breyta POS Profile
 DocType: Bank Reconciliation Detail,Clearance Date,úthreinsun Dagsetning
 apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Matsskýrsla
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Gross Purchase Amount is mandatory,Gross Purchase Upphæð er nauðsynlegur
+apps/erpnext/erpnext/setup/doctype/company/company.js +95,Company name not same,Nafn fyrirtækis er ekki sama
 DocType: Lead,Address Desc,Heimilisfang karbósýklískan
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +102,Party is mandatory,Party er nauðsynlegur
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +108,Party is mandatory,Party er nauðsynlegur
 DocType: Journal Entry,JV-,JV-
 apps/erpnext/erpnext/controllers/accounts_controller.py +707,Rows with duplicate due dates in other rows were found: {list},Röð með tvíhliða gjalddaga í öðrum röðum fundust: {list}
 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/accounts/doctype/pricing_rule/pricing_rule.py +37,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/hr/doctype/expense_claim/expense_claim.js +290,Select an employee to get the employee advance.,Veldu starfsmann til að fá starfsmanninn fyrirfram.
+apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,Vinsamlegast veldu gild dagsetningu
 apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Veldu eðli rekstrar þíns.
 DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
 <br>
@@ -3729,44 +3833,49 @@
 Grouped for test templates which are a group of other test templates.
 <br>
 No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Einstök fyrir niðurstöður sem þurfa aðeins eitt inntak, veldu UOM og eðlilegt gildi <br> Samsett fyrir niðurstöður sem krefjast margra inntaksvettvanga með samsvarandi nöfn á viðburði, veldu UOM og eðlilegt gildi <br> Lýsandi fyrir prófanir sem eru með margvíslegar niðurstöður og samsvarandi innsláttarreitir. <br> Flokkað fyrir próf sniðmát sem eru hópur annarra próf sniðmát. <br> Ekkert niðurstaða fyrir prófanir án árangurs. Einnig er engin Lab Test búin til. td. Undirprófanir fyrir samnýttar niðurstöður."
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +75,Row #{0}: Duplicate entry in References {1} {2},Row # {0}: Afrita færslu í tilvísunum {1} {2}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,Row #{0}: Duplicate entry in References {1} {2},Row # {0}: Afrita færslu í tilvísunum {1} {2}
 apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Hvar framleiðslu aðgerðir eru gerðar.
 apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,Sem prófdómari
 DocType: Asset Movement,Source Warehouse,Source Warehouse
 DocType: Installation Note,Installation Date,uppsetning Dagsetning
+apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Share Ledger
 apps/erpnext/erpnext/controllers/accounts_controller.py +605,Row #{0}: Asset {1} does not belong to company {2},Row # {0}: Asset {1} ekki tilheyra félaginu {2}
 apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Sölureikningur {0} búinn til
 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
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50,Min Qty can not be greater than Max Qty,Min Magn má ekki vera meiri en Max Magn
 DocType: Soil Texture,Silty Clay,Silty Clay
 DocType: Account,Accumulated Depreciation,uppsöfnuðum afskriftum
 DocType: Supplier Scorecard Scoring Standing,Standing Name,Stöðugt nafn
 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: Production Plan,Sales Orders Detail,Sölufyrirtæki
 DocType: Bin,Requested Quantity,Umbeðin Magn
 DocType: Patient,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-
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Idevise,Hugmyndafræði
 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_update_tool/bom_update_tool.py +26,Current BOM and New BOM can not be same,Núverandi BOM og New BOM getur ekki verið það sama
+apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29,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 +45,Salary Slip ID,Laun Slip ID
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,Dagsetning starfsloka verður að vera hærri en Dagsetning Tengja
 apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Margfeldi afbrigði
 DocType: Sales Invoice,Against Income Account,Against þáttatekjum
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Skilað
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +103,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ð).
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107,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
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +90,Please login as another user.,Vinsamlegast skráðu þig inn sem annar notandi.
+apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49,Please login as another user.,Vinsamlegast skráðu þig inn sem annar notandi.
+DocType: Daily Work Summary Group User,Daily Work Summary Group User,Daglegur vinnusamningur hópur notandi
 DocType: Territory,Territory Targets,Territory markmið
 DocType: Soil Analysis,Ca/Mg,Ca / Mg
 DocType: Delivery Note,Transporter Info,Transporter Upplýsingar
 apps/erpnext/erpnext/accounts/utils.py +502,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 +31,Same supplier has been entered multiple times,Sama birgir hefur verið slegið mörgum sinnum
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33,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
+,Warehouse wise Item Balance Age and Value,Vörugeymsla vitur Varajöfnuður Aldur og gildi
 DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Purchase Order Item Staðar
 apps/erpnext/erpnext/public/js/setup_wizard.js +94,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.
@@ -3790,6 +3899,7 @@
 apps/erpnext/erpnext/accounts/general_ledger.py +168,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
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332,Credit ({0}),Credit ({0})
 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æð
@@ -3801,13 +3911,13 @@
 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á."
+DocType: Asset Settings,Number of Days in Fiscal Year,Fjöldi daga á reikningsárinu
 ,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 +88,Purpose must be one of {0},Tilgangurinn verður að vera einn af {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +116,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/stock/doctype/stock_entry/stock_entry.py +92,Purpose must be one of {0},Tilgangurinn verður að vera einn af {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100,Fill the form and save it,Fylltu út formið og vista hana
 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 +52,Actual qty in stock,Raunverulegur fjöldi á lager
 DocType: Homepage,"URL for ""All Products""",URL fyrir &quot;Allar vörur&quot;
@@ -3817,9 +3927,11 @@
 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: Hotel Room Amenity,Billable,reikningshæfur
 DocType: Lab Test Template,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_balance/stock_balance.py +75,Reorder Qty,Uppröðun Magn
+DocType: Cash Flow Mapper,Section Name,Section Name
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77,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
@@ -3827,7 +3939,7 @@
 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/manufacturing/doctype/bom_update_tool/bom_update_tool.py +49,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Í biðstöðu fyrir að uppfæra nýjustu verð í öllum efnisskránni. Það getur tekið nokkrar mínútur.
+apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Í biðstöðu fyrir að uppfæra nýjustu verð í öllum efnisskránni. Það getur tekið nokkrar mínútur.
 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
 apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Land vitur sjálfgefið veffang Sniðmát
 DocType: Water Analysis,Appearance,Útlit
@@ -3838,7 +3950,7 @@
 apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Eignastýring
 ,Sales Payment Summary,Sala Greiðsla Yfirlit
 DocType: Restaurant,Restaurant,Veitingahús
-apps/erpnext/erpnext/accounts/party.py +323,Due / Reference Date cannot be after {0},Vegna / Reference Dagsetning má ekki vera á eftir {0}
+apps/erpnext/erpnext/accounts/party.py +321,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
 DocType: Patient,Account Details,Reikningsupplýsingar
 DocType: Crop,Materials Required,Efni sem krafist er
@@ -3849,6 +3961,7 @@
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,selja
 DocType: Purchase Invoice,Rounded Total,Ávalur Total
 DocType: Product Bundle,List items that form the package.,Listaatriði sem mynda pakka.
+apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39,Not permitted. Please disable the Test Template,Ekki leyfilegt. Vinsamlega slökkva á prófunarsniðinu
 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%
 DocType: Crop Cycle,Linked Land Unit,Tengd landseining
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Vinsamlegast veldu dagsetningu birtingar áður en þú velur Party
@@ -3856,17 +3969,17 @@
 DocType: Serial No,Out of AMC,Út af AMC
 apps/erpnext/erpnext/assets/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 +199,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
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +217,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 +62,Company (not Customer or Supplier) master.,Company (ekki viðskiptamenn eða birgja) skipstjóri.
 apps/erpnext/erpnext/education/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/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Engar nemendur í
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +171,Add more items or open full form,Bæta við fleiri atriði eða opnu fulla mynd
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179,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 +212,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/utilities/user_progress.py +256,Go to Users,Fara til notenda
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,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}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +131,Note: There is not enough leave balance for Leave Type {0},Athugið: Það er ekki nóg leyfi jafnvægi um leyfi Tegund {0}
 apps/erpnext/erpnext/regional/india/utils.py +16,Invalid GSTIN or Enter NA for Unregistered,Ógild GSTIN eða Sláðu inn NA fyrir óskráð
 DocType: Training Event,Seminar,Seminar
 DocType: Program Enrollment Fee,Program Enrollment Fee,Program innritunargjöld
@@ -3901,10 +4014,10 @@
 DocType: Chapter,Chapter Members,Kafla meðlimir
 DocType: Sales Team,Contribution (%),Framlag (%)
 apps/erpnext/erpnext/controllers/accounts_controller.py +101,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/projects/doctype/project/project.py +67,Project {0} already exists,Verkefni {0} er þegar til
+apps/erpnext/erpnext/projects/doctype/project/project.py +69,Project {0} already exists,Verkefni {0} er þegar til
 DocType: Medical Department,Nursing User,Hjúkrunarnotandi
 DocType: Plant Analysis,Plant Analysis Criterias,Greiningarkerfi plantna
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Responsibilities,ábyrgð
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Responsibilities,ábyrgð
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,Gildistími þessa tilvitnunar er lokið.
 DocType: Expense Claim Account,Expense Claim Account,Expense Krafa Reikningur
 DocType: Accounts Settings,Allow Stale Exchange Rates,Leyfa óbreyttu gengi
@@ -3912,25 +4025,28 @@
 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/utilities/user_progress.py +244,Add Users,Bæta notendur
 DocType: POS Item Group,Item Group,Liður Group
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Student Group: ,Nemendahópur:
 DocType: Item,Safety Stock,Safety Stock
 DocType: Healthcare Settings,Healthcare Settings,Heilbrigðisstofnanir
 apps/erpnext/erpnext/projects/doctype/task/task.py +54,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 +461,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
+apps/erpnext/erpnext/stock/doctype/item/item.py +475,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/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,Liður {0} verður að vera fast eign Item
-apps/erpnext/erpnext/stock/doctype/item/item.js +341,Make Variants,Gerðu afbrigði
+apps/erpnext/erpnext/stock/doctype/item/item.js +343,Make Variants,Gerðu afbrigði
 DocType: Item,Default BOM,Sjálfgefið BOM
 DocType: Project,Total Billed Amount (via Sales Invoices),Samtals innheimt upphæð (með sölutölum)
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +24,Debit Note Amount,Gengisskuldbinding
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +105,Debit Note Amount,Gengisskuldbinding
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106,"There are inconsistencies between the rate, no of shares and the amount calculated","Það eru ósamræmi á milli gengisins, hlutafjár og fjárhæð sem reiknað er út"
 apps/erpnext/erpnext/setup/doctype/company/company.js +89,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 +90,Total Outstanding Amt,Alls Framúrskarandi Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +197,Total Outstanding Amt,Alls Framúrskarandi Amt
 DocType: Journal Entry,Printing Settings,prentun Stillingar
 DocType: Employee Advance,Advance Account,Forgangsreikningur
+DocType: Job Offer,Job Offer Terms,Atvinnutilboðsskilmálar
 DocType: Sales Invoice,Include Payment (POS),Fela Greiðsla (POS)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +290,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/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/data/industry_type.py +11,Automotive,Automotive
 DocType: Vehicle,Insurance Company,Tryggingafélag
 DocType: Asset Category Account,Fixed Asset Account,Fast Asset Reikningur
@@ -3940,35 +4056,40 @@
 DocType: Student,Student Email Address,Student Netfang
 DocType: Item,Hub Warehouse,Hub Vörugeymsla
 DocType: Assessment Plan,From Time,frá Time
+DocType: Hotel Settings,Hotel Settings,Hótelstillingar
 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/data/industry_type.py +33,Investment Banking,Fyrirtækjaráðgjöf
+DocType: Purchase Invoice,input,inntak
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,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/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Námsmaður Heimilisfang
 DocType: Purchase Invoice,Price List Exchange Rate,Verðskrá Exchange Rate
 apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},Reikningsnúmer {0} þegar notað í reikningnum {1}
 DocType: POS Profile,POS Profile Name,POS prófíl nafn
+DocType: Hotel Room Reservation,Booked,Bókað
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxLib,CompAuxLib
 DocType: Purchase Invoice Item,Rate,Gefa
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Intern
 DocType: Delivery Stop,Address Name,netfang Nafn
 DocType: Stock Entry,From BOM,frá BOM
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639,Splitting {0} units of {1},Splitting {0} einingar af {1}
 DocType: Assessment Code,Assessment Code,mat Code
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,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 +219,Please click on 'Generate Schedule',Vinsamlegast smelltu á &#39;Búa Stundaskrá&#39;
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,Reference No is mandatory if you entered Reference Date,Tilvísunarnúmer er nauðsynlegt ef þú færð viðmiðunardagur
+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/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Villa við að meta viðmiðunarformúluna
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,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/data/industry_type.py +9,Airline,Airline
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +852,Issue Material,Issue Efni
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853,Issue Material,Issue Efni
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Villa kom upp við endurkomu
 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 +727,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/accounts/page/pos/pos.js +735,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/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,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æð
@@ -3976,23 +4097,27 @@
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Row # {0}: Væntanlegur Afhendingardagur getur ekki verið fyrir Purchase Order Date
 DocType: Purchase Invoice,Print Language,Print Tungumál
 DocType: Salary Slip,Total Working Hours,Samtals Vinnutíminn
+DocType: Sales Invoice,Customer PO Details,Upplýsingar viðskiptavina
 DocType: Subscription,Next Schedule Date,Næsta Dagsetning Dagsetning
 DocType: Stock Entry,Including items for sub assemblies,Þ.mt atriði fyrir undir þingum
 DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Tímabundin opnunareikningur
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1944,Enter value must be positive,Sláðu gildi verður að vera jákvæð
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +392,All Territories,Allir Territories
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1962,Enter value must be positive,Sláðu gildi verður að vera jákvæð
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446,All Territories,Allir Territories
 DocType: Purchase Invoice,Items,atriði
 apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,Student is already enrolled.,Nemandi er nú skráður.
 DocType: Fiscal Year,Year Name,ár Name
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Það eru fleiri frídagar en vinnudögum þessum mánuði.
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78,PDC/LC Ref,PDC / LC Ref
 DocType: Product Bundle Item,Product Bundle Item,Vara Knippi Item
 DocType: Sales Partner,Sales Partner Name,Heiti Sales Partner
 apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Beiðni um tilvitnanir
 DocType: Payment Reconciliation,Maximum Invoice Amount,Hámarks Invoice Amount
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Montantdevise,Montantdevise
 apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Blóðmyndun
 DocType: Normal Test Items,Normal Test Items,Venjuleg prófunaratriði
 DocType: Student Language,Student Language,Student Tungumál
 apps/erpnext/erpnext/config/selling.py +23,Customers,viðskiptavinir
+DocType: Cash Flow Mapping,Is Working Capital,Er vinnumarkaður
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Order / Quot%
 apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Skráðu sjúklinga vitaleika
 DocType: Fee Schedule,Institution,stofnun
@@ -4000,12 +4125,12 @@
 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/data/industry_type.py +46,Securities & Commodity Exchanges,Verðbréf &amp; hrávöru ungmennaskipti
-apps/erpnext/erpnext/stock/doctype/item/item.py +661,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;
+apps/erpnext/erpnext/stock/doctype/item/item.py +688,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/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Engar starfsmenn fyrir nefndar viðmiðanir
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +944,No Items with Bill of Materials to Manufacture,Engar Verk með Bill of Materials að Manufacture
-DocType: Restaurant,Default Customer,Sjálfgefið viðskiptavinur
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +946,No Items with Bill of Materials to Manufacture,Engar Verk með Bill of Materials að Manufacture
+DocType: Hotel Settings,Default Customer,Sjálfgefið viðskiptavinur
 DocType: Assessment Plan,Supervisor Name,Umsjón Name
 DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Ekki staðfestu ef skipun er búin til fyrir sama dag
 DocType: Program Enrollment Course,Program Enrollment Course,Forritunarnámskeið
@@ -4013,7 +4138,7 @@
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Stigatöflur
 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
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Cash Flow from Operations,Handbært fé frá rekstri
 DocType: Purchase Invoice,Shipping Rule,Sendingar Regla
 DocType: Patient Relation,Spouse,Maki
 DocType: Lab Test Groups,Add Test,Bæta við prófun
@@ -4026,7 +4151,7 @@
 DocType: Journal Entry Account,Employee Advance,Starfsmaður
 DocType: Payroll Entry,Payroll Frequency,launaskrá Tíðni
 DocType: Lab Test Template,Sensitivity,Viðkvæmni
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +62,Raw Material,Hrátt efni
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +932,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 +55,Plants and Machineries,Plöntur og Machineries
 DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Skatthlutfall Eftir Afsláttur Upphæð
@@ -4035,7 +4160,7 @@
 DocType: Payment Entry,Internal Transfer,innri Transfer
 DocType: Asset Maintenance,Maintenance Tasks,Viðhaldsverkefni
 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/accounts/doctype/journal_entry/journal_entry.js +367,Please select Posting Date first,Vinsamlegast veldu dagsetningu birtingar fyrst
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Posting Date first,Vinsamlegast veldu dagsetningu birtingar fyrst
 apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Opnun Date ætti að vera áður lokadegi
 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
@@ -4056,11 +4181,12 @@
 DocType: Fees,Student Email,Nemandi tölvupóstur
 DocType: Supplier,Prevent POs,Hindra POs
 DocType: Patient,"Allergies, Medical and Surgical History","Ofnæmi, læknisfræði og skurðlækningar"
-apps/erpnext/erpnext/templates/generators/item.html +62,Add to Cart,Bæta í körfu
+apps/erpnext/erpnext/templates/generators/item.html +77,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 +298,Enable / disable currencies.,Virkja / slökkva á gjaldmiðla.
-DocType: Production Planning Tool,Get Material Request,Fá Material Beiðni
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +110,Dr {0} on Half day Leave on {1},Dr {0} á hálftíma Leyfi á {1}
+DocType: Production Plan,Get Material Request,Fá Material Beiðni
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,pósti Útgjöld
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Alls (Amt)
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Skemmtun &amp; Leisure
@@ -4071,13 +4197,14 @@
 apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,bókhald Yfirlýsingar
 DocType: Drug Prescription,Hour,klukkustund
 DocType: Restaurant Order Entry,Last Sales Invoice,Síðasta sala Reikningur
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +799,Please select Qty against item {0},Vinsamlegast veldu Magn á hlut {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +789,Please select Qty against item {0},Vinsamlegast veldu Magn á hlut {0}
 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 +383,All these items have already been invoiced,Öll þessi atriði hafa þegar verið reikningsfærð
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,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 +392,All these items have already been invoiced,Öll þessi atriði hafa þegar verið reikningsfærð
 DocType: Company,Monthly Sales Target,Mánaðarlegt sölumarkmið
 apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Getur verið samþykkt af {0}
+DocType: Hotel Room,Hotel Room Type,Hótel Herbergi
 DocType: Item,Default Material Request Type,Default Efni Beiðni Type
 DocType: Supplier Scorecard,Evaluation Period,Matartímabil
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,óþekkt
@@ -4090,13 +4217,11 @@
 DocType: Patient,Widow,Ekkja
 DocType: GST Settings,GSTIN Email Sent On,GSTIN Email Sent On
 DocType: Program Enrollment,Pick/Drop by Guardian,Pick / Drop með forráðamanni
-DocType: Production Planning Tool,"Create for full quantity, ignoring quantity already on order","Búa til fullt magn, hunsa magn þegar á röð"
 DocType: Crop,Planting UOM,Gróðursetning UOM
 DocType: Account,Tax,Tax
 apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,ekki Marked
 apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Opna reikningsyfirlit
 DocType: Education Settings,Education Manager,Menntun Framkvæmdastjóri
-DocType: Production Planning Tool,Production Planning Tool,Framleiðsla Planning Tool
 DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,Lágmarkslengdin milli hvers plöntu á vettvangi fyrir bestu vöxt
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"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
@@ -4104,43 +4229,46 @@
 DocType: C-Form,Invoices,reikningar
 DocType: Water Analysis,Type of Sample,Tegund sýni
 DocType: Batch,Source Document Name,Heimild skjal Nafn
+DocType: Production Plan,Get Raw Materials For Production,Fáðu hráefni til framleiðslu
 DocType: Job Opening,Job Title,Starfsheiti
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
 					have been quoted. Updating the RFQ quote status.",{0} gefur til kynna að {1} muni ekki gefa til kynna en allir hlutir \ hafa verið vitnar í. Uppfæra RFQ vitna stöðu.
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1004,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Hámarksýni - {0} hafa þegar verið haldið fyrir lotu {1} og lið {2} í lotu {3}.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1012,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Hámarksýni - {0} hafa þegar verið haldið fyrir lotu {1} og lið {2} í lotu {3}.
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125,Please Set Supplier Type in Buying Settings.,Vinsamlegast settu Birgir Tegund innkaupastillingar.
 DocType: Manufacturing Settings,Update BOM Cost Automatically,Uppfæra BOM kostnað sjálfkrafa
 DocType: Lab Test,Test Name,Próf Nafn
 apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Búa notendur
 apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,Gram
 DocType: Supplier Scorecard,Per Month,Á mánuði
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +414,Quantity to Manufacture must be greater than 0.,Magn á Framleiðsla verður að vera hærri en 0.
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +433,Quantity to Manufacture must be greater than 0.,Magn á Framleiðsla verður að vera hærri en 0.
+DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Reiknaðu gengislækkunaráætlun miðað við reikningsár
 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 +120,New Batch ID (Optional),Ný lotunúmer (valfrjálst)
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),Ný lotunúmer (valfrjálst)
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,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/hub_node/page/hub/hub.js +196,Newest,Nýjasta
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +167,Please cancel Purchase Invoice {0} first,Vinsamlegast hætta kaupa Reikningar {0} fyrst
+apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47,Net Change in Equity,Net breyting á eigin fé
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +220,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 +869,Receipt,kvittun
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +871,Receipt,kvittun
 ,Sales Register,velta Nýskráning
-DocType: Daily Work Summary Settings Company,Send Emails At,Senda póst At
+DocType: Daily Work Summary Group,Send Emails At,Senda póst At
 DocType: Quotation,Quotation Lost Reason,Tilvitnun Lost Ástæða
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +368,Transaction reference no {0} dated {1},Tilvísunarnúmer viðskipta engin {0} dagsett {1}
+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; Numbers Series
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,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/selling/page/point_of_sale/point_of_sale.js +483,Form View,Eyðublað
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Samantekt fyrir þennan mánuð og bið starfsemi
 apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Bættu notendum við fyrirtækið þitt, annað en sjálfan þig."
 DocType: Customer Group,Customer Group Name,Viðskiptavinar Group Name
 apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Engar viðskiptavinir ennþá!
 apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,Sjóðstreymi
+apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +472,No material request created,Engin efnisbeiðni búin til
 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 +478,Please remove this Invoice {0} from C-Form {1},Vinsamlegast fjarlægðu þennan reikning {0} úr C-Form {1}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +489,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: Physician,Phone (R),Sími (R)
@@ -4151,8 +4279,9 @@
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Síðasta Röð Dagsetning
 DocType: Patient,B Negative,B neikvæð
 apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Viðhald Staða verður að vera Hætt eða lokið til að senda inn
+DocType: Hotel Room,Hotel Room,Hótelherbergi
 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 +871,Serial Numbers in row {0} does not match with Delivery Note,Raðnúmer í röð {0} samsvarar ekki við Afhendingartilkynningu
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +882,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
@@ -4160,7 +4289,8 @@
 DocType: Vehicle,Chassis No,undirvagn Ekkert
 DocType: Payment Request,Initiated,hafin
 DocType: Production Order,Planned Start Date,Áætlaðir Start Date
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +596,Please select a BOM,Vinsamlegast veldu BOM
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613,Please select a BOM,Vinsamlegast veldu BOM
+DocType: Purchase Invoice,Availed ITC Integrated Tax,Notaður ITC samlaga skatt
 DocType: Serial No,Creation Document Type,Creation Document Type
 DocType: Project Task,View Timesheet,Skoða tímasetningu
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,Lokadagur verður að vera meiri en upphafsdagur
@@ -4178,6 +4308,10 @@
 DocType: Student Admission Program,Student Admission Program,Námsmenntun
 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/hr/doctype/payroll_entry/payroll_entry.py +461,"Could not submit any Salary Slip <br>\
+			Possible reasons: <br>\
+			1. Net pay is less than 0. <br>\
+			2. Company Email Address specified in employee master is not valid. <br>",Gat ekki sent neinar launagreiðslur <br> \ Mögulegar ástæður: <br> \ 1. Hrein laun er minna en 0. <br> \ 2. Fyrirtæki netfang sem tilgreint er í starfsmanni meistara er ógilt. <br>
 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
@@ -4188,47 +4322,50 @@
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Series er nauðsynlegur
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Financial Services
 DocType: Student Sibling,Student ID,Student ID
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +457,Supplier Email,Birgir Email
 apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Tegundir starfsemi fyrir Time Logs
 DocType: Opening Invoice Creation Tool,Sales,velta
 DocType: Stock Entry Detail,Basic Amount,grunnfjárhæð
 DocType: Training Event,Exam,Exam
 DocType: Complaint,Complaint,Kvörtun
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +449,Warehouse required for stock Item {0},Warehouse krafist fyrir hlutabréfum lið {0}
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +460,Warehouse required for stock Item {0},Warehouse krafist fyrir hlutabréfum lið {0}
 DocType: Leave Allocation,Unused leaves,ónotuð leyfi
 DocType: Patient,Alcohol Past Use,Áfengisnotkun áfengis
 DocType: Fertilizer Content,Fertilizer Content,Áburður innihaldsefni
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +188,Cr,cr
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187,Cr,cr
 DocType: Tax Rule,Billing State,Innheimta State
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +296,Transfer,Transfer
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +916,Fetch exploded BOM (including sub-assemblies),Ná sprakk BOM (þ.mt undireiningar)
+DocType: Share Transfer,Transfer,Transfer
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917,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 +136,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
+apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Vöxtur fyrir eigind {0} er ekki verið 0
+apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Herbergi bókað
 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
+DocType: Shareholder,Contact HTML,Viltu samband við HTML
+apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Skráningargjald getur ekki verið núll
 DocType: Disease,Treatment Period,Meðferðartímabil
+apps/erpnext/erpnext/education/api.py +338,Result already Submitted,Niðurstaða þegar send
 apps/erpnext/erpnext/controllers/buying_controller.py +169,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,Frátekið vörugeymsla er skylt að skila vöru {0} í hráefni
 ,Inactive Customers,óvirka viðskiptamenn
 DocType: Student Admission Program,Maximum Age,Hámarksaldur
+apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,Vinsamlegast bíðið 3 dögum áður en áminningin er send aftur.
 DocType: Landed Cost Voucher,LCV,LCV
 DocType: Landed Cost Voucher,Purchase Receipts,Purchase Kvittanir
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,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
 apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Smásala
 DocType: Student Attendance,Absent,Absent
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,vara Bundle
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Ekki er hægt að finna stig sem byrjar á {0}. Þú þarft að standa frammistöðu sem nær yfir 0 til 100
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +206,No submitted Delivery Notes found,Engar sendar skilatilkynningar fundust
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +210,Row {0}: Invalid reference {1},Row {0}: Ógild vísun {1}
+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: 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: Hotel Room Amenity,Hotel Room Amenity,Hótelið aðstaða
 DocType: Payment Entry,Account Paid From,Reikningur greitt frá
 DocType: Purchase Order Item Supplied,Raw Material Item Code,Raw Material Item Code
 DocType: Task,Parent Task,Foreldraverkefni
@@ -4236,8 +4373,8 @@
 apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,gera Blý
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,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 +807,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/buying/doctype/request_for_quotation/request_for_quotation.js +809,Send Supplier Emails,Senda Birgir póst
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +97,"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."
 DocType: Chapter Member,Leave Reason,Skildu ástæðu
 DocType: Guardian Interest,Guardian Interest,Guardian Vextir
 DocType: Volunteer,Availability,Framboð
@@ -4248,15 +4385,16 @@
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,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
 DocType: Lab Prescription,Test Code,Prófunarregla
 apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Stillingar fyrir heimasíðu heimasíðuna
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +38,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs eru ekki leyfð fyrir {0} vegna þess að stigatafla sem stendur fyrir {1}
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},RFQs eru ekki leyfð fyrir {0} vegna þess að stigatafla sem stendur fyrir {1}
 DocType: Delivery Stop,Select/Unselect Delivery Notes,Veldu / aftengja sendingarskýringar
-DocType: Offer Letter,Awaiting Response,bíður svars
+DocType: Job Offer,Awaiting Response,bíður svars
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,hér að framan
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1399,Total Amount {0},Samtals upphæð {0}
-apps/erpnext/erpnext/controllers/item_variant.py +301,Invalid attribute {0} {1},Ógild eiginleiki {0} {1}
+apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1462,Total Amount {0},Samtals upphæð {0}
+apps/erpnext/erpnext/controllers/item_variant.py +303,Invalid attribute {0} {1},Ógild eiginleiki {0} {1}
 DocType: Supplier,Mention if non-standard payable account,Tilgreindu ef ekki staðlað greiðslureikningur
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +18,Please select the assessment group other than 'All Assessment Groups',Vinsamlegast veldu matshópinn annað en &#39;Öll matshópa&#39;
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25,Please select the assessment group other than 'All Assessment Groups',Vinsamlegast veldu matshópinn annað en &#39;Öll matshópa&#39;
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Rú {0}: Kostnaðurarmiðstöð er krafist fyrir hlut {1}
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureDate,EcritureDate
 DocType: Training Event Employee,Optional,Valfrjálst
 DocType: Salary Slip,Earning & Deduction,Launin &amp; Frádráttur
 DocType: Agriculture Analysis Criteria,Water Analysis,Vatnsgreining
@@ -4279,10 +4417,10 @@
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Kostnaður við rifið Eignastýring
 apps/erpnext/erpnext/controllers/stock_controller.py +236,{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 +684,Get Items from Product Bundle,Fá atriði úr Vara Knippi
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686,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 +64,Split,Skipta
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,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 +156,Please enter 'Is Subcontracted' as Yes or No,Vinsamlegast sláðu inn &quot;Er undirverktöku&quot; eins já eða nei
@@ -4295,16 +4433,16 @@
 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á
-apps/erpnext/erpnext/config/learn.py +273,Publish Items on Website,Birta Atriði á vefsvæðinu
+apps/erpnext/erpnext/config/learn.py +263,Publish Items on Website,Birta Atriði á vefsvæðinu
 apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Hópur nemenda þín í lotur
 DocType: Authorization Rule,Authorization Rule,Heimildin Regla
 DocType: POS Profile,Offline POS Section,Offline POS Section
 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
+apps/erpnext/erpnext/templates/generators/item.html +100,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 +114,New Batch Qty,Ný lotunúmer
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,Ný lotunúmer
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Fatnaður &amp; Aukabúnaður
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,Gat ekki leyst veginn skora virka. Gakktu úr skugga um að formúlan sé gild.
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Fjöldi Order
@@ -4314,14 +4452,15 @@
 DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Hlutverk leyft að setja á frysta reikninga &amp; Sýsla Frozen færslur
 DocType: Supplier Scorecard Scoring Variable,Path,Leið
 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 +66,Opening Value,opnun Value
+DocType: Production Plan,Total Planned Qty,Samtals áætlað magn
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,Opening Value,opnun Value
 DocType: Salary Detail,Formula,Formula
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Serial #
 DocType: Lab Test Template,Lab Test Template,Lab Test Sniðmát
-apps/erpnext/erpnext/setup/doctype/company/company.py +170,Sales Account,Sölureikningur
+apps/erpnext/erpnext/setup/doctype/company/company.py +181,Sales Account,Sölureikningur
 DocType: Purchase Invoice Item,Total Weight,Heildarþyngd
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Þóknun á sölu
-DocType: Offer Letter Term,Value / Description,Gildi / Lýsing
+DocType: Job Offer Term,Value / Description,Gildi / Lýsing
 apps/erpnext/erpnext/controllers/accounts_controller.py +629,"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
@@ -4329,11 +4468,12 @@
 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}.
 DocType: Asset Maintenance Task,Assign To Name,Úthluta til nafns
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,risnu
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +63,Make Material Request,Gera Material Beiðni
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98,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 +222,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
 DocType: Consultation,Age,Aldur
 DocType: Sales Invoice Timesheet,Billing Amount,Innheimta Upphæð
+DocType: Cash Flow Mapping,Select Maximum Of 1,Veldu hámark 1
 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.
 DocType: Company,Default Employee Advance Account,Sjálfstætt starfandi reikningsskil
 apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Umsókn um leyfi.
@@ -4344,11 +4484,11 @@
 apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Gerðu opnun sölu- og innkaupakostna
 DocType: Purchase Invoice,Posting Time,staða Time
 DocType: Timesheet,% Amount Billed,% Magn Billed
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.",&quot;Tími fyrir hvert skipun&quot; hefur ekki verið settur fyrir Dr {0}. Bættu því við í lækni meistara.
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +130,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.",&quot;Tími fyrir hvert skipun&quot; hefur ekki verið settur fyrir Dr {0}. Bættu því við í lækni meistara.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,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 +129,No Item with Serial No {0},Ekkert atriði með Serial nr {0}
+apps/erpnext/erpnext/stock/get_item_details.py +131,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 +79,Direct Expenses,bein Útgjöld
@@ -4369,18 +4509,20 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,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 +809,Return / Credit Note,Return / Credit Note
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811,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 +23,Total Paid Amount,Samtals greitt upphæð
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +104,Total Paid Amount,Samtals greitt upphæð
+DocType: GST Settings,B2C Limit,B2C takmörk
 DocType: Production Order Item,Transferred Qty,flutt Magn
 apps/erpnext/erpnext/config/learn.py +11,Navigating,siglingar
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,áætlanagerð
-DocType: Material Request,Issued,Útgefið
+DocType: Share Balance,Issued,Útgefið
 apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Námsmat
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,birgir Id
 DocType: Payment Request,Payment Gateway Details,Greiðsla Gateway Upplýsingar
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +267,Quantity should be greater than 0,Magn ætti að vera meiri en 0
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +277,Quantity should be greater than 0,Magn ætti að vera meiri en 0
 DocType: Journal Entry,Cash Entry,Cash Entry
+DocType: Production Plan,Get Items For Production Order,Fáðu vörur til framleiðslufyrirmæla
 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
@@ -4388,7 +4530,7 @@
 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 +305,Please set default account in Expense Claim Type {0},Vinsamlegast settu sjálfgefin reikningur í kostnað kröfutegund {0}
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +280,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 +143,Payroll Payable,launaskrá Greiðist
@@ -4408,11 +4550,12 @@
 apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Laun sniðmát húsbóndi.
 apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Sjúkdómar
 DocType: Restaurant Order Entry,Restaurant Table,Veitingahús borðstofa
+DocType: Hotel Room,Hotel Manager,Hótelstjórinn
 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 +48,Abbreviation is mandatory,Skammstöfun er nauðsynlegur
+apps/erpnext/erpnext/setup/doctype/company/company.py +49,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
@@ -4422,7 +4565,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,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 +774,{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 +41,Tax Template is mandatory.,Tax Snið er nauðsynlegur.
+apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +43,Tax Template is mandatory.,Tax Snið er nauðsynlegur.
 apps/erpnext/erpnext/accounts/doctype/account/account.py +44,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
@@ -4430,13 +4573,14 @@
 DocType: Lab Prescription,Test Created,Próf búin til
 DocType: Healthcare Settings,Custom Signature in Print,Sérsniðin undirskrift í prenti
 DocType: Account,Temporary,tímabundin
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +95,Customer LPO No.,Viðskiptavinur LPO nr.
 DocType: Program,Courses,námskeið
 DocType: Monthly Distribution Percentage,Percentage Allocation,hlutfall Úthlutun
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,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: Supplier Scorecard Criteria,Criteria Name,Viðmiðunarheiti
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1289,Please set Company,Vinsamlegast settu fyrirtækið
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295,Please set Company,Vinsamlegast settu fyrirtækið
 DocType: Pricing Rule,Buying,Kaup
 apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Sjúkdómar og áburður
 DocType: HR Settings,Employee Records to be created by,Starfskjör Records að vera búin með
@@ -4447,20 +4591,24 @@
 ,Reqd By Date,Reqd By Date
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,lánardrottnar
 DocType: Assessment Plan,Assessment Name,mat Name
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +88,Show PDC in Print,Sýna PDC í prenti
 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/hr/doctype/job_applicant/job_applicant.js +13,Job Offer,Atvinnutilboð
 apps/erpnext/erpnext/public/js/setup_wizard.js +71,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 +970,Supplier Quotation,birgir Tilvitnun
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1073,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 +158,Quantity ({0}) cannot be a fraction in row {1},Magn ({0}) getur ekki verið brot í röð {1}
+apps/erpnext/erpnext/utilities/transaction_base.py +160,Quantity ({0}) cannot be a fraction in row {1},Magn ({0}) getur ekki verið brot í röð {1}
 DocType: Consultation,C-,C-
 DocType: Attendance,ATT-,viðhorfin
-apps/erpnext/erpnext/stock/doctype/item/item.py +473,Barcode {0} already used in Item {1},Strikamerki {0} nú þegar notuð í lið {1}
+apps/erpnext/erpnext/stock/doctype/item/item.py +491,Barcode {0} already used in Item {1},Strikamerki {0} nú þegar notuð í lið {1}
 apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Reglur til að bæta sendingarkostnað.
+DocType: Hotel Room,Extra Bed Capacity,Auka rúmgetu
 DocType: Item,Opening Stock,opnun Stock
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Viðskiptavinur er krafist
 DocType: Lab Test,Result Date,Niðurstaða Dagsetning
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77,PDC/LC Date,PDC / LC Dagsetning
 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/utilities/user_progress.py +249,user@example.com,user@example.com
@@ -4469,21 +4617,21 @@
 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/data/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
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +196,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 +66,Select Fiscal Year...,Veldu fjárhagsársins ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +554,POS Profile required to make POS Entry,POS Profile þarf að gera POS Entry
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +565,POS Profile required to make POS Entry,POS Profile þarf að gera POS Entry
 DocType: Program Enrollment Tool,Enroll Students,innritast Nemendur
 DocType: Lab Test,Approved Date,Samþykkt dagsetning
 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 +148,Atleast one warehouse is mandatory,Atleast einn vöruhús er nauðsynlegur
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +152,Atleast one warehouse is mandatory,Atleast einn vöruhús er nauðsynlegur
 DocType: Serial No,Out of Warranty,Út ábyrgðar
 DocType: BOM Update Tool,Replace,Skipta
 apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Engar vörur fundust.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +358,{0} against Sales Invoice {1},{0} gegn sölureikningi {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} gegn sölureikningi {1}
 DocType: Antibiotic,Laboratory User,Laboratory User
 DocType: Sales Invoice,SINV-,SINV-
 DocType: Request for Quotation Item,Project Name,nafn verkefnis
@@ -4491,14 +4639,14 @@
 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
+apps/erpnext/erpnext/config/learn.py +229,Human Resource,Mannauðs
 DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Greiðsla Sættir Greiðsla
 DocType: Disease,Treatment Task,Meðferðarlisti
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,skattinneign
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +631,Production Order has been {0},Framleiðslufyrirmæli hefur verið {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +653,Production Order has been {0},Framleiðslufyrirmæli hefur verið {0}
 DocType: BOM Item,BOM No,BOM Nei
 DocType: Instructor,INS/,INS /
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +158,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
+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 Update 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 +46,Electronic Equipments,rafræn útbúnaður
@@ -4513,12 +4661,14 @@
 apps/erpnext/erpnext/controllers/accounts_controller.py +599,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Row # {0}: Asset er nauðsynlegur fyrir fast eign kaup / sölu
 DocType: Asset Maintenance Team,Maintenance Team Name,Viðhald Team Name
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","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/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,Viðskiptavinur er skyltur ef &quot;Tækifæri frá&quot; er valinn sem viðskiptavinur
 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 +137,Types of Expense Claim.,Tegundir kostnað kröfu.
 apps/erpnext/erpnext/controllers/selling_controller.py +147,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
+DocType: Purchase Invoice,capital goods,fjármagnsvörur
 DocType: Purchase Invoice Item,Weight Per Unit,Þyngd á hverja einingu
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Greitt og ekki afhent
 DocType: Project,Default Cost Center,Sjálfgefið Kostnaður Center
@@ -4536,9 +4686,10 @@
 apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Viðskiptavinir og birgja
 DocType: Item Attribute,From Range,frá Range
 DocType: BOM,Set rate of sub-assembly item based on BOM,Stilla hlutfall af undir-samkoma atriði byggt á BOM
+DocType: Hotel Room Reservation,Invoiced,Innheimt
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,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 +123,Item {0} ignored since it is not a stock item,Liður {0} hunsuð þar sem það er ekki birgðir atriði
+apps/erpnext/erpnext/stock/utils.py +125,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 +109,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 +23,"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."
@@ -4551,8 +4702,8 @@
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +36,Production Item,framleiðsla Item
 ,Employee Information,starfsmaður Upplýsingar
 DocType: Stock Entry Detail,Additional Cost,aukakostnaðar
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +44,"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 +916,Make Supplier Quotation,Gera Birgir Tilvitnun
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48,"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 +918,Make Supplier Quotation,Gera Birgir Tilvitnun
 DocType: Quality Inspection,Incoming,Komandi
 apps/erpnext/erpnext/setup/doctype/company/company.js +70,Default tax templates for sales and purchase are created.,Sjálfgefin skatta sniðmát fyrir sölu og kaup eru búnar til.
 DocType: BOM,Materials Required (Exploded),Efni sem þarf (Sprakk)
@@ -4561,10 +4712,9 @@
 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/templates/emails/recurring_document_failed.html +10,for generating the recurring,til að búa til endurtekin
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Kjóll Leave
-apps/erpnext/erpnext/config/healthcare.py +139,Lab Test UOM.,Lab Próf UOM.
 DocType: Agriculture Task,End Day,Lokadagur
 DocType: Batch,Batch ID,hópur ID
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +378,Note: {0},Ath: {0}
+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 +112,This Week's Summary,Samantekt Í þessari viku er
 apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Á lager Magn
@@ -4584,11 +4734,14 @@
 DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",Fyrir námsmiðaðan nemendahóp verður námskeiðið valið fyrir alla nemenda frá skráðum námskeiðum í námskrá.
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,ákvæðisvinnu
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Avg. kaupgengi
+DocType: Share Balance,From No,Frá nr
 DocType: Task,Actual Time (in Hours),Tíminn (í klst)
 DocType: Employee,History In Company,Saga In Company
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +311,New Message from {sender},Ný skilaboð frá {sendanda}
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270,New Message from {sender},Ný skilaboð frá {sendanda}
+DocType: Customer,Customer Primary Address,Aðalnafn viðskiptavinar
 apps/erpnext/erpnext/config/learn.py +107,Newsletters,Fréttabréf
 DocType: Drug Prescription,Description/Strength,Lýsing / styrkur
+DocType: Share Balance,Is Company,Er félagið
 DocType: Stock Ledger Entry,Stock Ledger Entry,Stock Ledger Entry
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Sama atriði hefur verið gert mörgum sinnum
 DocType: Department,Leave Block List,Skildu Block List
@@ -4605,37 +4758,39 @@
 ,Project Quantity,Project Magn
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","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 +375,{0} units of {1} needed in {2} to complete this transaction.,{0} einingar {1} þörf {2} að ljúka þessari færslu.
+apps/erpnext/erpnext/stock/stock_ledger.py +377,{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
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,tímabundin reikningar
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Black
 DocType: BOM Explosion Item,BOM Explosion Item,BOM Sprenging Item
+DocType: Shareholder,Contact List,Tengiliðir
 DocType: Account,Auditor,endurskoðandi
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} atriði framleitt
 apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Læra meira
 DocType: Cheque Print Template,Distance from top edge,Fjarlægð frá efstu brún
-apps/erpnext/erpnext/stock/get_item_details.py +365,Price List {0} is disabled or does not exist,Verðlisti {0} er óvirk eða er ekki til
+apps/erpnext/erpnext/stock/get_item_details.py +367,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 +186,Mode of payment is required to make a payment,Háttur af greiðslu er krafist til að greiða
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +178,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/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Breyta í fullri síðu fyrir fleiri valkosti eins og eignir, raðnúmer, lotur osfrv."
 apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Tilnefningar og samráð
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} er ekki skráður í lotuna {2}
 apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"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}"
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +67,Cheques Required,Athuganir krafist
 DocType: Task,Total Expense Claim (via Expense Claim),Total Expense Krafa (með kostnað kröfu)
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Mark Absent
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Mistókst að setja upp fyrirtæki
 DocType: Asset Repair,Asset Repair,Eignastýring
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +140,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}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +142,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
 DocType: Patient,Additional information regarding the patient,Viðbótarupplýsingar um sjúklinginn
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +572,Sales Order {0} is not submitted,Velta Order {0} er ekki lögð
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +583,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 +204,Fleet Management,Lo Stjórn
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +968,Add items from,Bæta atriði úr
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1071,Add items from,Bæta atriði úr
 apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Korn og lönd
 DocType: Cheque Print Template,Regular,Venjulegur
 DocType: Fertilizer,Density (if liquid),Density (ef vökvi)
@@ -4649,23 +4804,24 @@
 DocType: Training Event,Contact Number,Númer tengiliðs
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,Warehouse {0} er ekki til
 DocType: Monthly Distribution,Monthly Distribution Percentages,Mánaðarleg Dreifing Prósentur
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +58,The selected item cannot have Batch,Valið atriði getur ekki Hópur
+apps/erpnext/erpnext/stock/doctype/batch/batch.py +110,The selected item cannot have Batch,Valið atriði getur ekki Hópur
 DocType: Delivery Note,% of materials delivered against this Delivery Note,% Af efnum afhent gegn þessum Delivery Note
 DocType: Asset Maintenance Log,Has Certificate,Hefur vottorð
 DocType: Project,Customer Details,Nánar viðskiptavina
 DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Athugaðu hvort eignir krefjast fyrirbyggjandi viðhalds eða kvörðunar
+apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,Fyrirtæki Skammstöfun getur ekki haft meira en 5 stafi
 DocType: Employee,Reports to,skýrslur til
 ,Unpaid Expense Claim,Ógreitt Expense Krafa
 DocType: Payment Entry,Paid Amount,greiddur Upphæð
 apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Kynntu söluferli
 DocType: Assessment Plan,Supervisor,Umsjón
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +867,Retention Stock Entry,Varðveisla birgða
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869,Retention Stock Entry,Varðveisla birgða
 ,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
 apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,Sem umsjónarmaður
 DocType: BOM Scrap Item,BOM Scrap Item,BOM Scrap Item
-apps/erpnext/erpnext/accounts/page/pos/pos.js +887,Submitted orders can not be deleted,Lagðar pantanir ekki hægt að eyða
+apps/erpnext/erpnext/accounts/page/pos/pos.js +895,Submitted orders can not be deleted,Lagðar pantanir ekki hægt að eyða
 apps/erpnext/erpnext/accounts/doctype/account/account.py +114,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","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/operations/install_fixtures.py +118,Quality Management,Gæðastjórnun
 apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,Liður {0} hefur verið gerð óvirk
@@ -4673,7 +4829,7 @@
 DocType: Agriculture Task,Previous Business Day,Fyrri viðskiptadagur
 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}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +89,Credit Note Amt,Lánshæfiseinkunn Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +196,Credit Note Amt,Lánshæfiseinkunn Amt
 DocType: Employee External Work History,Employee External Work History,Starfsmaður Ytri Vinna Saga
 DocType: Opening Invoice Creation Tool,Purchase,kaup
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Balance Magn
@@ -4696,14 +4852,13 @@
 DocType: Payment Entry,Set Exchange Gain / Loss,Setja gengishagnaður / tap
 ,GST Purchase Register,GST Purchase Register
 ,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
 apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,Sameinað reikningshluti verður jafn 100%
 DocType: Item Group,Default Expense Account,Sjálfgefið kostnað reiknings
 DocType: GST Account,CGST Account,CGST reikningur
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,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 +2468,Select items to save the invoice,Veldu atriði til að bjarga reikning
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2494,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: Special Test Template,Special Test Template,Sérstök próf sniðmát
@@ -4711,8 +4866,10 @@
 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/config/accounts.py +471,List of all share transactions,Listi yfir alla hlutafjáreignir
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Upp Count
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +242,Please find attached {0} #{1},Meðfylgjandi {0} # {1}
+apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244,Please find attached {0} #{1},Meðfylgjandi {0} # {1}
+apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Meðaltal
 apps/erpnext/erpnext/controllers/accounts_controller.py +721,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Samtals greiðslugjald í greiðsluáætlun verður að vera jafnt við Grand / Rounded Total
 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
@@ -4735,16 +4892,19 @@
 DocType: Guardian,Guardian Of ,Guardian Of
 DocType: Grading Scale Interval,Threshold,þröskuldur
 DocType: BOM Update Tool,Current BOM,Núverandi BOM
-apps/erpnext/erpnext/public/js/utils.js +49,Add Serial No,Bæta Serial Nei
+apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +25,Balance (Dr - Cr),Jafnvægi (Dr - Cr)
+apps/erpnext/erpnext/public/js/utils.js +55,Add Serial No,Bæta Serial Nei
 DocType: Production Order Item,Available Qty at Source Warehouse,Laus magn í Source Warehouse
 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/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} eign er ekki hægt að flytja
+DocType: Hotel Room Pricing,Hotel Room Pricing,Hótel herbergi Verðlagning
 apps/erpnext/erpnext/stock/doctype/item/item.js +80,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
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84,Customer LPO,Viðskiptavinur LPO
 DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Fyrir hópur sem byggist á hópnum, verður námsmatið valið fyrir alla nemendum frá námsbrautinni."
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,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.
 apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Dreifing
@@ -4755,18 +4915,19 @@
 ,Quoted Item Comparison,Vitnað Item Samanburður
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Skarast í skora á milli {0} og {1}
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,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/doctype/pricing_rule/pricing_rule.py +74,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 +176,Net Asset value as on,Innra virði og á
 DocType: Crop,Produce,Framleiða
+DocType: Hotel Settings,Default Taxes and Charges,Sjálfgefin skatta og gjöld
 DocType: Account,Receivable,viðskiptakröfur
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,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 +978,Select Items to Manufacture,Veldu Hlutir til Manufacture
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +980,Select Items to Manufacture,Veldu Hlutir til Manufacture
 DocType: Delivery Stop,Delivery Stop,Afhending Stöðva
-apps/erpnext/erpnext/accounts/page/pos/pos.js +955,"Master data syncing, it might take some time","Master gögn syncing, gæti það tekið smá tíma"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +963,"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: Employee Education,Qualification,HM
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +40,View Salary Slips,Skoðaðu launakort
+apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42,View Salary Slips,Skoðaðu launakort
 DocType: Item Price,Item Price,Item verð
 apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Sápa &amp; Þvottaefni
 DocType: BOM,Show Items,Sýna Items
@@ -4790,7 +4951,7 @@
 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 +222,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
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +231,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
 apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,&quot;Viðtakendur&quot; ekki tilgreind
 DocType: BOM Update Tool,Update latest price in all BOMs,Uppfæra nýjustu verð í öllum BOMs
@@ -4800,25 +4961,26 @@
 apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} verður að senda inn
 DocType: POS Profile,Item Groups,Item Hópar
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,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
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +163,Please add a Temporary Opening account in Chart of Accounts,Vinsamlegast bættu við tímabundna opnunareikning í reikningsskýringu
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186,Please add a Temporary Opening account in Chart of Accounts,Vinsamlegast bættu við tímabundna opnunareikning í reikningsskýringu
 DocType: Customer,Customer Primary Contact,Tengiliður viðskiptavina
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154,Period Closing Journal,Tímabil Lokadagur
 DocType: Project Task,View Task,view Task
 apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Upp / Leið%
 DocType: Material Request,MREQ-,MREQ-
 DocType: Payment Schedule,Invoice Portion,Reikningshluti
 ,Asset Depreciations and Balances,Eignastýring Afskriftir og jafnvægi
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Amount {0} {1} transferred from {2} to {3},Upphæð {0} {1} flutt frá {2} til {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +363,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 +491,Transaction not allowed against stopped Production Order {0},Transaction ekki leyft móti hætt framleiðslu Order {0}
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +498,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 +216,Join,Join
+DocType: Production Plan,Include Subcontracted Items,Inniheldur undirverktaka
+apps/erpnext/erpnext/projects/doctype/project/project.py +218,Join,Join
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,skortur Magn
-apps/erpnext/erpnext/stock/doctype/item/item.py +645,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Ekki er hægt að breyta Variant eiginleika eftir birgðir umskipti. Þú verður að búa til nýtt atriði til að gera þetta.
-apps/erpnext/erpnext/stock/doctype/item/item.py +685,Item variant {0} exists with same attributes,Liður afbrigði {0} hendi með sömu eiginleika
+apps/erpnext/erpnext/stock/doctype/item/item.py +671,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Ekki er hægt að breyta Variant eiginleika eftir birgðir umskipti. Þú verður að búa til nýtt atriði til að gera þetta.
+apps/erpnext/erpnext/stock/doctype/item/item.py +713,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 +347,Requesting payment against {0} {1} for amount {2},Biðum greiðslu gegn {0} {1} fyrir upphæð {2}
@@ -4843,38 +5005,41 @@
 DocType: Employee Education,Employee Education,starfsmaður Menntun
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Afrit atriði hópur í lið töflunni
 DocType: Land Unit,Parent Land Unit,Móðurhlutdeild
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1101,It is needed to fetch Item Details.,Það er nauðsynlegt að ná Item upplýsingar.
+apps/erpnext/erpnext/public/js/controllers/transaction.js +1113,It is needed to fetch Item Details.,Það er nauðsynlegt að ná Item upplýsingar.
 DocType: Fertilizer,Fertilizer Name,Áburður Nafn
 DocType: Salary Slip,Net Pay,Net Borga
-DocType: Account,Account,Reikningur
+DocType: Cash Flow Mapping Accounts,Account,Reikningur
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,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
 DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),"Hiti í kjölfarið (hitastig&gt; 38,5 ° C / viðvarandi hitastig&gt; 38 ° C / 100,4 ° F)"
 DocType: Customer,Sales Team Details,Upplýsingar Söluteymi
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1342,Delete permanently?,Eyða varanlega?
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1351,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}
+DocType: Shareholder,Folio no.,Folio nr.
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246,Invalid {0},Ógild {0}
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,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/data/industry_type.py +22,Department Stores,Department Stores
 ,Item Delivery Date,Liður afhendingardags
+DocType: Production Plan,Material Requested,Efni sem óskað er eftir
 DocType: Warehouse,PIN,PIN
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +125,Error '{0}' occured. Arguments {1}.,Villa &#39;{0}&#39; átti sér stað. Skýringar {1}.
+apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +124,Error '{0}' occured. Arguments {1}.,Villa &#39;{0}&#39; átti sér stað. Skýringar {1}.
 DocType: Bin,Reserved Qty for sub contract,Frátekin fjöldi undirverktaka
 DocType: Sales Invoice,Base Change Amount (Company Currency),Base Breyta Upphæð (Company Gjaldmiðill)
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,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 +111,Save the document first.,Vistaðu skjalið fyrst.
-apps/erpnext/erpnext/shopping_cart/cart.py +71,Only {0} in stock for item {1},Aðeins {0} á lager fyrir hlut {1}
+apps/erpnext/erpnext/shopping_cart/cart.py +74,Only {0} in stock for item {1},Aðeins {0} á lager fyrir hlut {1}
 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/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Credit Days má ekki vera neikvætt númer
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Síðasta Order Magn
-apps/erpnext/erpnext/stock/doctype/item/item.py +264," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Halda sýn er byggð á lotu, vinsamlegast athugaðu Hefur Hópur nr. Til að halda sýnishorn af hlut"
+DocType: Cash Flow Mapper,e.g Adjustments for:,td leiðréttingar fyrir:
+apps/erpnext/erpnext/stock/doctype/item/item.py +274," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Halda sýn er byggð á lotu, vinsamlegast athugaðu Hefur Hópur nr. Til að halda sýnishorn af hlut"
 DocType: Task,Is Milestone,Er Milestone
 DocType: Delivery Stop,Email Sent To,Tölvupóstur sendur til
 DocType: Budget,Warn,Warn
@@ -4883,7 +5048,7 @@
 DocType: Asset Maintenance,Manufacturing User,framleiðsla User
 DocType: Purchase Invoice,Raw Materials Supplied,Raw Materials Staðar
 DocType: C-Form,Series,Series
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +273,Currency of the price list {0} must be {1} or {2},Gjaldmiðill verðlista {0} verður að vera {1} eða {2}
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +283,Currency of the price list {0} must be {1} or {2},Gjaldmiðill verðlista {0} verður að vera {1} eða {2}
 DocType: Appraisal,Appraisal Template,Úttekt Snið
 DocType: Soil Texture,Ternary Plot,Ternary plot
 DocType: Item Group,Item Classification,Liður Flokkun
@@ -4901,7 +5066,7 @@
 DocType: Salary Detail,Salary Detail,laun Detail
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,Vinsamlegast veldu {0} fyrst
 DocType: Appointment Type,Physician,Læknir
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +850,Batch {0} of Item {1} has expired.,Hópur {0} af Liður {1} hefur runnið út.
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +858,Batch {0} of Item {1} has expired.,Hópur {0} af Liður {1} hefur runnið út.
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Samráð
 DocType: Sales Invoice,Commission,þóknun
 apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Tími Sheet fyrir framleiðslu.
@@ -4922,7 +5087,7 @@
 DocType: Item Customer Detail,Ref Code,Ref Code
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Viðskiptavinahópur er krafist í POS Profile
 apps/erpnext/erpnext/config/hr.py +12,Employee records.,Employee færslur.
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +95,Please set Next Depreciation Date,Vinsamlegast settu Next Afskriftir Dagsetning
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +98,Please set Next Depreciation Date,Vinsamlegast settu Next Afskriftir Dagsetning
 DocType: HR Settings,Payroll Settings,launaskrá Stillingar
 apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Passa non-tengd og greiðslur.
 DocType: POS Settings,POS Settings,POS stillingar
@@ -4934,15 +5099,15 @@
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Þjálfun viðburðir / niðurstöður
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,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 +419,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/manufacturing/doctype/production_order/production_order.py +438,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 +106,Warehouse is mandatory,Warehouse er nauðsynlegur
-DocType: Supplier,Address and Contacts,Heimilisfang og Tengiliðir
+DocType: Shareholder,Address and Contacts,Heimilisfang og Tengiliðir
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Mistókst að búa til vefsíðu
 DocType: Soil Analysis,Mg/K,Mg / K
 DocType: UOM Conversion Detail,UOM Conversion Detail,UOM viðskipta Detail
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +922,Retention Stock Entry already created or Sample Quantity not provided,Varðveislubréf þegar búið er til eða sýnishorn Magn ekki til staðar
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924,Retention Stock Entry already created or Sample Quantity not provided,Varðveislubréf þegar búið er til eða sýnishorn Magn ekki til staðar
 DocType: Program,Program Abbreviation,program Skammstöfun
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +407,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/manufacturing/doctype/production_order/production_order.py +426,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 +52,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
@@ -4956,10 +5121,13 @@
 DocType: Item,Average time taken by the supplier to deliver,Meðaltal tíma tekin af birgi að skila
 DocType: Sample Collection,Collected By,Safnað með
 apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35,Assessment Result,mat Niðurstaða
+DocType: Hotel Room Package,Hotel Room Package,Hótel herbergi pakki
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,klukkustundir
 DocType: Project,Expected Start Date,Væntanlegur Start Date
+DocType: Purchase Invoice,04-Correction in Invoice,04-leiðrétting á reikningi
 apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Variant Details Report
 DocType: Setup Progress Action,Setup Progress Action,Uppsetning Framfarir
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vinsamlega settu upp starfsmannamiðlunarkerfi í mannauði&gt; HR-stillingar
 apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Buying Price List,Kaupverðskrá
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Fjarlægja hlut ef gjöld eru ekki við þann lið
 apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Vinsamlegast veldu Viðhaldsstaða sem lokið eða fjarlægðu Lokadagsetning
@@ -4973,42 +5141,42 @@
 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: Subscription,Submit on creation,Senda á sköpun
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +470,Currency for {0} must be {1},Gjaldeyri fyrir {0} verður að vera {1}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +476,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 +485,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/stock/doctype/item/item.py +509,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 +99,"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 +16,Training Feedback,Þjálfun Feedback
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +488,Production Order {0} must be submitted,Framleiðslu Order {0} Leggja skal fram
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +495,Production Order {0} must be submitted,Framleiðslu Order {0} Leggja skal fram
 DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Birgir Scorecard Criteria
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Vinsamlegast veldu Ræsa og lokadag fyrir lið {0}
 apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,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 +268,Add / Edit Prices,Bæta við / Breyta Verð
+DocType: Cash Flow Mapper,Section Footer,Section Footer
+apps/erpnext/erpnext/stock/doctype/item/item.js +275,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
 DocType: Lab Test Template,Sample Collection,Sýnishorn
 ,Requested Items To Be Ordered,Umbeðin Items til að panta
-apps/erpnext/erpnext/hub_node/page/hub/hub.js +655,My Orders,Pantanir mínir
+apps/erpnext/erpnext/public/js/hub/hub_page.js +137,My Orders,Pantanir mínir
 DocType: Price List,Price List Name,Verðskrá Name
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +32,Daily Work Summary for {0},Daily Work Yfirlit fyrir {0}
 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 +150,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 +266,Sales Invoice {0} has already been submitted,Velta Invoice {0} hefur þegar verið lögð
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +106,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 +275,Sales Invoice {0} has already been submitted,Velta Invoice {0} hefur þegar verið lögð
 DocType: Supplier Scorecard Scoring Criteria,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
 DocType: Asset Maintenance Log,Completion Date,Verklok
 DocType: Purchase Invoice Item,Amount (Company Currency),Upphæð (Company Gjaldmiðill)
 DocType: Agriculture Analysis Criteria,Agriculture User,Landbúnaður Notandi
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,Gildir til dagsetning geta ekki verið fyrir viðskiptadag
-apps/erpnext/erpnext/stock/stock_ledger.py +379,{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.
+apps/erpnext/erpnext/stock/stock_ledger.py +381,{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 Schedule,Student Category,Student Flokkur
 DocType: Announcement,Student,Student
 apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Organization eining (umdæmi) skipstjóri.
@@ -5018,19 +5186,21 @@
 DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,LYFJA FOR LEIÐBEININGAR
 DocType: Email Digest,Pending Quotations,Bíður Tilvitnun
 apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Point-af-sölu Profile
+apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +24,{0} should be a value between 0 and 100,{0} ætti að vera gildi á milli 0 og 100
+apps/erpnext/erpnext/assets/doctype/asset/asset.py +94,Next Depreciation Date cannot be before Available-for-use Date,Næsta Afskriftir Dagsetning má ekki vera fyrir dagsetningu sem hægt er að nota
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Ótryggð Lán
 DocType: Cost Center,Cost Center Name,Kostnaður Center Name
 DocType: Student,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 +88,Total Paid Amt,Alls Greiddur Amt
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +195,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
 DocType: Hub Settings,Company and Seller Profile,Fyrirtæki og seljanda
 ,GST Itemised Sales Register,GST hlutasala
 DocType: Soil Texture,Silt Loam,Silt Loam
 ,Serial No Service Contract Expiry,Serial Nei Service Contract gildir til
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +297,You cannot credit and debit same account at the same time,Þú getur ekki kredit-og debetkort sama reikning á sama tíma
+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: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Púls hlutfall fullorðinna er einhvers staðar á milli 50 og 80 slög á mínútu.
 DocType: Naming Series,Help HTML,Hjálp HTML
 DocType: Student Group Creation Tool,Student Group Creation Tool,Student Group Creation Tool
@@ -5041,35 +5211,36 @@
 apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,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 +382,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 +364,Received From,fékk frá
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370,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 +24,{0}: From {0} for {1},{0}: Frá {0} fyrir {1}
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","Eins og á kaupstillingarnar, ef kaupheimildin er krafist == &#39;YES&#39;, þá til að búa til innheimtufé, þarf notandi að búa til kaupgreiðsluna fyrst fyrir atriði {0}"
 apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Row # {0}: Setja Birgir fyrir lið {1}
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,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 +185,Website Image {0} attached to Item {1} cannot be found,Vefsíða Image {0} fylgir tl {1} er ekki hægt að finna
+apps/erpnext/erpnext/stock/doctype/item/item.py +194,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
 DocType: Asset,Assets,Eignir
 apps/erpnext/erpnext/setup/setup_wizard/data/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.
 DocType: Payment Term,Due Date Based On,Gjalddagi Byggt á
 apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Vinsamlegast stilltu sjálfgefinn viðskiptavinahóp og landsvæði í Sölustillingar
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +203,{0} {1} does not exist,{0} {1} er ekki til
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +321,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 +85,Item: {0} does not exist in the system,Item: {0} er ekki til í kerfinu
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not exist,{0} {1} er ekki til
+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 +87,Item: {0} does not exist in the system,Item: {0} er ekki til í kerfinu
 apps/erpnext/erpnext/accounts/doctype/account/account.py +106,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
 DocType: Healthcare Settings,Laboratory Settings,Laboratory Settings
+apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Settu Birgðasali vel
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Skildu Encashment
 apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Hvað gerir það?
 DocType: Crop,Byproducts,Byproducts
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +76,To Warehouse,til Warehouse
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,til Warehouse
 apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Allir Student Innlagnir
 ,Average Commission Rate,Meðal framkvæmdastjórnarinnar Rate
-apps/erpnext/erpnext/stock/doctype/item/item.py +434,'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ð
+DocType: Share Balance,No of Shares,Fjöldi hlutabréfa
+apps/erpnext/erpnext/stock/doctype/item/item.py +447,'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/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Veldu stöðu
 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
@@ -5080,7 +5251,7 @@
 apps/erpnext/erpnext/utilities/activation.py +100,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)
 DocType: Grant Application,Requested Amount,Óskað eftir upphæð
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +346,Row {0}: Exchange Rate is mandatory,Row {0}: Exchange Rate er nauðsynlegur
+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: Crop Cycle,Detected Diseases,Uppgötvaðir sjúkdómar
@@ -5089,7 +5260,7 @@
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Afmæli Áminning fyrir {0}
 DocType: Asset Maintenance Task,Last Completion Date,Síðasti lokadagur
 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 +352,Debit To account must be a Balance Sheet account,Debit Til reikning verður að vera Efnahagur reikning
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +363,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
@@ -5102,33 +5273,36 @@
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,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 +325,Salary Slip of employee {0} already created for time sheet {1},Laun Slip starfsmanns {0} þegar búið fyrir tíma blaði {1}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +324,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 +713,Item {0} is disabled,Liður {0} er óvirk
+DocType: Production Plan Item,Ordered Qty,Raðaður Magn
+apps/erpnext/erpnext/stock/doctype/item/item.py +743,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 +929,BOM does not contain any stock item,BOM inniheldur ekki lager atriði
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930,BOM does not contain any stock item,BOM inniheldur ekki lager atriði
 DocType: Chapter,Chapter Head,Kafli höfuð
 DocType: Payment Term,Month(s) after the end of the invoice month,Mánuður (s) eftir lok reiknings mánaðar
 apps/erpnext/erpnext/config/projects.py +19,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/agriculture/doctype/water_analysis/water_analysis.py +24,Lab result datetime cannot be before testing datetime,Lab niðurstaða datetime getur ekki verið fyrir prófunartíma
+DocType: POS Profile,Allow user to edit Discount,Leyfa notanda að breyta afslátt
+DocType: Production Plan Item,Include Exploded Items,Inniheldur sprauta hluti
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45,"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
 DocType: Shipping Rule,Restrict to Countries,Takmarka við lönd
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +171,Select Delivery Notes,Veldu Afhendingartilkynningar
 DocType: Purchase Invoice,Write Off Amount (Company Currency),Skrifaðu Off Upphæð (Company Gjaldmiðill)
 DocType: Sales Invoice Timesheet,Billing Hours,Billing Hours
 DocType: Project,Total Sales Amount (via Sales Order),Samtals sölugjald (með sölupöntun)
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +529,Default BOM for {0} not found,Sjálfgefið BOM fyrir {0} fannst ekki
-apps/erpnext/erpnext/stock/doctype/item/item.py +489,Row #{0}: Please set reorder quantity,Row # {0}: Vinsamlegast settu pöntunarmark magn
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +548,Default BOM for {0} not found,Sjálfgefið BOM fyrir {0} fannst ekki
+apps/erpnext/erpnext/stock/doctype/item/item.py +513,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: Share Transfer,To Folio No,Til Folio nr
 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}
 apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{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 +24,To create a Payment Request reference document is required,Til að búa til greiðslubeiðni þarf viðmiðunarskjal
 DocType: Soil Texture,Sandy Clay,Sandy Clay
 DocType: Grant Application,Assessment  Manager,Matsstjóri
@@ -5141,27 +5315,27 @@
 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
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +225,"{0} {1} is associated with {2}, but Party Account is {3}",{0} {1} tengist {2} en samningsreikningur er {3}
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +231,"{0} {1} is associated with {2}, but Party Account is {3}",{0} {1} tengist {2} en samningsreikningur er {3}
 apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Skoða Lab Próf
 DocType: Purchase Invoice,Y,Y
 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/selling/doctype/customer/customer.py +108,Please mention the Lead Name in Lead {0},Vinsamlegast nefnt Lead Name í Lead {0}
+apps/erpnext/erpnext/selling/doctype/customer/customer.py +124,Please mention the Lead Name in Lead {0},Vinsamlegast nefnt Lead Name í Lead {0}
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,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 +535,BOM and Manufacturing Quantity are required,BOM og framleiðsla Magn þarf
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +571,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/setup/setup_wizard/setup_wizard.py +28,Installing presets,Uppsetning forstillingar
 apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +67,No Delivery Note selected for Customer {},Engin afhendingartilkynning valin fyrir viðskiptavini {}
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +22,BOM replaced,BOM stað
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1041,Select Items based on Delivery Date,Veldu Atriði byggt á Afhendingardagur
+apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25,BOM replaced,BOM stað
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1043,Select Items based on Delivery Date,Veldu Atriði byggt á Afhendingardagur
 DocType: Grant Application,Has any past Grant Record,Hefur einhverjar fyrri styrkleikaskrár
 ,Sales Analytics,velta Analytics
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +119,Available {0},Laus {0}
+apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127,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
@@ -5171,10 +5345,11 @@
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,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 +88,Tax Rule Conflicts with {0},Tax regla Árekstrar með {0}
+apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +90,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
+DocType: Hotel Room Reservation,Hotel Room Reservation,Hótel herbergi fyrirvara
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Þjónustuver
 DocType: BOM,Thumbnail,Smámynd
 DocType: Item Customer Detail,Item Customer Detail,Liður Viðskiptavinur Detail
@@ -5188,6 +5363,7 @@
 apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Sjálfgefnar stillingar fyrir bókhald viðskiptum.
 DocType: Maintenance Visit,MV,MV
 DocType: Restaurant,Default Tax Template,Sjálfgefið Skattamót
+apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66,{0} Students have been enrolled,{0} Nemendur hafa verið skráðir
 DocType: Fees,Student Details,Nánari upplýsingar
 DocType: Purchase Invoice Item,Stock Qty,Fjöldi hluta
 DocType: Employee Loan,Repayment Period in Months,Lánstími í mánuði
@@ -5211,15 +5387,13 @@
 apps/erpnext/erpnext/config/projects.py +41,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 +273,Installation Note {0} has already been submitted,Uppsetning Ath {0} hefur þegar verið lögð fram
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282,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/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Viðskiptavinur&gt; Viðskiptavinahópur&gt; Territory
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,skoða Now
 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 +64,Gantt Chart,Gantt Mynd
 DocType: Crop Cycle,Cycle Type,Hringrásartegund
 apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Hluta
@@ -5234,29 +5408,32 @@
 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}
+DocType: Projects Settings,Ignore User Time Overlap,Hunsa User Time skarast
 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 +138,Split Batch,Skipta lotu
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Skipta lotu
 DocType: Stock Settings,Batch Identification,Hópur auðkenni
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,tókst Samræmd
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,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
+DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Falinn listi heldur lista yfir tengiliði sem tengjast hluthafa
 apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Upplýsingar um gjafa Upplýsingar.
 DocType: Request for Quotation,Supplier Detail,birgir Detail
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Villa í formúlu eða ástandi: {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +16,Invoiced Amount,Upphæð á reikningi
+apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +87,Invoiced Amount,Upphæð á reikningi
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Viðmiðunarþyngd verður að bæta allt að 100%
 apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Aðsókn
 apps/erpnext/erpnext/public/js/pos/pos.html +104,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/opening_invoice_creation_tool/opening_invoice_creation_tool.py +103,Creating {0},Búa til {0}
+apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111,Creating {0},Búa til {0}
 apps/erpnext/erpnext/assets/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 +566,Posting date and posting time is mandatory,Staða dagsetningu og staða tími er nauðsynlegur
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +573,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
 DocType: Consultation,Review Details,Endurskoða upplýsingar
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185,The shareholder does not belong to this company,Hluthafi er ekki tilheyrandi þessum fyrirtækjum
 DocType: Dosage Form,Dosage Form,Skammtaform
 apps/erpnext/erpnext/config/selling.py +67,Price List master.,Verðskrá húsbóndi.
 DocType: Task,Review Date,Review Date
@@ -5264,8 +5441,8 @@
 DocType: Membership,Member Since,Meðlimur síðan
 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 +171,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/item_variant.py +92,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 +175,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
 DocType: Restaurant Reservation,Waitlisted,Bíddu á lista
 apps/erpnext/erpnext/accounts/doctype/account/account.py +124,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: Shipping Rule,Fixed,Fastur
@@ -5278,25 +5455,28 @@
 DocType: Purchase Invoice,Contact Email,Netfang tengiliðar
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Gjöld vegna verðtryggingar
 DocType: Appraisal Goal,Score Earned,skora aflað
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Notice Period,uppsagnarfrestur
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240,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: Asset Maintenance Task,Preventive Maintenance,Fyrirbyggjandi viðhald
 DocType: Delivery Note Item,Against Sales Invoice,Against sölureikningi
+DocType: Purchase Invoice,07-Others,07-aðrir
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Vinsamlegast sláðu inn raðnúmer fyrir raðnúmer
 DocType: Bin,Reserved Qty for Production,Frátekið Magn fyrir framleiðslu
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureNum,EcritureNum
 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 +501,Credit Account,Credit Reikningur
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500,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
 DocType: Lab Test,Test Group,Test Group
 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 +680,Please specify Attribute Value for attribute {0},Vinsamlegast tilgreindu Attribute virði fyrir eigind {0}
+DocType: Company,Company Logo,Fyrirtæki Logo
+apps/erpnext/erpnext/stock/doctype/item/item.py +708,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}
 DocType: Healthcare Settings,Patient Registration,Sjúklingur skráning
@@ -5316,17 +5496,20 @@
 DocType: Lab Test Groups,Lab Test Groups,Lab Test Groups
 DocType: Project,Total Expense Claim (via Expense Claims),Total Expense Krafa (með kostnað kröfum)
 DocType: GST Settings,GST Summary,GST Yfirlit
+apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16,Please enable default incoming account before creating Daily Work Summary Group,Vinsamlegast virkjaðu sjálfgefna komandi reikning áður en þú býrð til dagvinnuupplýsingahóp
 DocType: Assessment Result,Total Score,Total Score
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +116,Please set the Default Cost Center in {0} company,Vinsamlega stilltu sjálfgefna kostnaðarmiðstöðina í {0} fyrirtæki
 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ð
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49,ValidDate,ValidDate
 DocType: Student Log,Achievement,Achievement
 DocType: Batch,Source Document Type,Heimild skjal tegund
 apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Eftirfarandi námskeið voru búnar til
 DocType: Journal Entry,Total Debit,alls skuldfærsla
 DocType: Manufacturing Settings,Default Finished Goods Warehouse,Sjálfgefin fullunnum Warehouse
+apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +124,Please select Patient,Vinsamlegast veldu Sjúklingur
 apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Sölufulltrúa
+DocType: Hotel Room Package,Amenities,Aðstaða
 apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Fjárhagsáætlun og kostnaður Center
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,Margfeldi sjálfgefið greiðslumáti er ekki leyfilegt
 apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,fyrir
@@ -5337,9 +5520,11 @@
 DocType: Healthcare Settings,Consultations in valid days,Samráð á gildum dögum
 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: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Sjóðstreymisreikningar
 apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,Hópur rúlla nr
 DocType: Batch,Manufacturing Date,Framleiðslutími
 apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,Fee Creation mistókst
+DocType: Opening Invoice Creation Tool,Create Missing Party,Búðu til vantar aðila
 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
@@ -5349,35 +5534,34 @@
 ,BOM Stock Report,BOM Stock Report
 DocType: Stock Reconciliation Item,Quantity Difference,magn Mismunur
 DocType: Employee Advance,EA-,EA-
-apps/erpnext/erpnext/config/hr.py +320,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 +175,Set as Lost,Setja sem Lost
+apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173,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: Company,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}
+apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,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: Program Enrollment Tool,New Academic Term,Nýtt fræðasvið
 ,Course wise Assessment Report,Námsmatsmatsskýrsla
+DocType: Purchase Invoice,Availed ITC State/UT Tax,Notaði ITC ríki / UT skatt
 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/healthcare/doctype/patient_appointment/patient_appointment.py +92,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} hefur ekki læknaáætlun. Bættu því við í lækni meistara
+apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +120,Dr {0} does not have a Physician Schedule. Add it in Physician master,Dr {0} hefur ekki læknaáætlun. Bættu því við í lækni meistara
 apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Viðskiptavinir í biðröð
 DocType: Driver,Issuing Date,Útgáfudagur
 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 +1375,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 +179,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/page/pos/pos.js +1384,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 +171,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
 DocType: Assessment Result,Summary,Yfirlit
 apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Mark Aðsókn
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +495,Debit Account,skuldfærslureikning
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494,Debit Account,skuldfærslureikning
 DocType: Fiscal Year,Year Start Date,Ár Start Date
 DocType: Attendance,Employee Name,starfsmaður Name
 DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Veitingahús Order Entry Item
@@ -5387,32 +5571,35 @@
 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.
 DocType: Asset Maintenance Team,Maintenance Team Members,Viðhaldsliðsmenn
 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 +259,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/operations/install_fixtures.py +232,Employee Benefits,starfskjör
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packed quantity must equal quantity for Item {0} in row {1},Pakkað magn verður að vera jafnt magn fyrir lið {0} í röð {1}
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,Birgir Tilvitnun {0} búin
+apps/erpnext/erpnext/accounts/report/financial_statements.py +101,End Year cannot be before Start Year,Árslok getur ekki verið áður Start Ár
+apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233,Employee Benefits,starfskjör
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264,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
+apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78,The shares don't exist with the {0},Hlutarnir eru ekki til með {0}
 apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Reikningur búin til
 DocType: Asset,Out of Order,Bilað
 DocType: Purchase Receipt Item,Accepted Quantity,Samþykkt Magn
+DocType: Projects Settings,Ignore Workstation Time Overlap,Hunsa vinnustöðartímann
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,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 +31,{0}: {1} does not exists,{0}: {1} er ekki til
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Veldu hópnúmer
 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 +532,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}
+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: Assessment Plan,Schedule,Dagskrá
 DocType: Account,Parent Account,Parent Reikningur
 apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,Laus
 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 +1707,Price List not found or disabled,Verðlisti fannst ekki eða fatlaður
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1716,Price List not found or disabled,Verðlisti fannst ekki eða fatlaður
 DocType: Student Applicant,Approved,samþykkt
-DocType: Pricing Rule,Price,verð
+apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,verð
 apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',Starfsmaður létta á {0} skal stilla eins &#39;Vinstri&#39;
 DocType: Hub Settings,Last Sync On,Síðasta samstilling á
 DocType: Guardian,Guardian,Guardian
+DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Búðu til vantar viðskiptavini eða birgi.
 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: Academic Term,Education,menntun
 apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,Del
@@ -5426,12 +5613,12 @@
 DocType: Asset Repair,Repair Status,Viðgerðarstaða
 apps/erpnext/erpnext/config/accounts.py +67,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 +327,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 +215,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Row {0}: Party / Account passar ekki við {1} / {2} í {3} {4}
+DocType: Purchase Invoice,input service,inntakstími
+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}
 DocType: Maintenance Team Member,Maintenance Team Member,Viðhaldsliðsmaður
 DocType: Agriculture Analysis Criteria,Soil Analysis,Jarðgreining
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Course Code: ,Námskeiðskóði:
+apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13,Course Code: ,Námskeiðskóði:
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Vinsamlegast sláðu inn kostnað reikning
 DocType: Account,Stock,Stock
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Row # {0}: Tilvísun Document Type verður að vera einn af Purchase Order, Purchase Invoice eða Journal Entry"
@@ -5439,19 +5626,18 @@
 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 +325,Batch Inventory,hópur Inventory
+apps/erpnext/erpnext/config/stock.py +329,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: Lab Test,Prescription,Ávísun
-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
 apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Ekki í boði
 DocType: Pricing Rule,Min Qty,min Magn
 apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Slökkva á sniðmáti
 DocType: GL Entry,Transaction Date,Færsla Dagsetning
 DocType: Production Plan Item,Planned Qty,Planned Magn
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total Tax
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +187,For Quantity (Manufactured Qty) is mandatory,Fyrir Magn (Framleiðandi Magn) er nauðsynlegur
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +191,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/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,The Year End Date getur ekki verið fyrr en árið Start Date. Vinsamlega leiðréttu dagsetningar og reyndu aftur.
@@ -5464,7 +5650,7 @@
 DocType: Hub Settings,Hub Settings,Hub Stillingar
 DocType: Project,Gross Margin %,Heildarframlegð %
 DocType: BOM,With Operations,með starfsemi
-apps/erpnext/erpnext/accounts/party.py +262,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}.
+apps/erpnext/erpnext/accounts/party.py +260,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
 DocType: Warranty Claim,If different than customer address,Ef öðruvísi en viðskiptavinur heimilisfangi
@@ -5473,7 +5659,7 @@
 apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Uppfylling
 DocType: Purchase Taxes and Charges,On Previous Row Amount,Á fyrri röð Upphæð
 DocType: Item,Has Expiry Date,Hefur gildistími
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +269,Transfer Asset,Transfer Asset
+apps/erpnext/erpnext/assets/doctype/asset/asset.js +282,Transfer Asset,Transfer Asset
 DocType: POS Profile,POS Profile,POS Profile
 DocType: Training Event,Event Name,Event Name
 DocType: Physician,Phone (Office),Sími (Skrifstofa)
@@ -5481,14 +5667,15 @@
 apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Innlagnir fyrir {0}
 apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Árstíðum til að setja fjárveitingar, markmið o.fl."
 DocType: Supplier Scorecard Scoring Variable,Variable Name,Breytilegt nafn
-apps/erpnext/erpnext/stock/get_item_details.py +142,"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
+apps/erpnext/erpnext/stock/get_item_details.py +144,"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/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Net borga ekki vera neikvæð
 DocType: Purchase Order,Advance Paid,Advance Greiddur
 DocType: Item,Item Tax,Liður Tax
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +872,Material to Supplier,Efni til Birgir
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Material to Supplier,Efni til Birgir
 DocType: Soil Texture,Loamy Sand,Loamy Sand
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +594,Excise Invoice,vörugjöld Invoice
+DocType: Production Plan,Material Request Planning,Efni beiðni um skipulagningu
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +630,Excise Invoice,vörugjöld Invoice
 apps/erpnext/erpnext/education/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
@@ -5498,8 +5685,9 @@
 DocType: Program,Program Name,program Name
 DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Íhuga skatta og álaga fyrir
 DocType: Driver,Driving License Category,Ökuskírteini Flokkur
+apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158,No Reference,Engin tilvísun
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Raunveruleg Magn er nauðsynlegur
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +88,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} er nú með {1} Birgir Stuðningskort og kauptilboð til þessa birgis skulu gefin út með varúð.
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} er nú með {1} Birgir Stuðningskort og kauptilboð til þessa birgis skulu gefin út með varúð.
 DocType: Asset Maintenance Team,Asset Maintenance Team,Eignastýringarteymi
 DocType: Employee Loan,Loan Type,lán Type
 DocType: Scheduling Tool,Scheduling Tool,Tímasetningar Tool
@@ -5519,14 +5707,14 @@
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Vinsamlegast veldu félagið fyrst
 DocType: Item Attribute,Numeric Values,talnagildi
 apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,hengja Logo
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +43,Stock Levels,lager Levels
+apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,lager Levels
 DocType: Customer,Commission Rate,Framkvæmdastjórnin Rate
 apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,Búið til {0} stigakort fyrir {1} á milli:
-apps/erpnext/erpnext/stock/doctype/item/item.js +473,Make Variant,gera Variant
+apps/erpnext/erpnext/stock/doctype/item/item.js +475,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 +144,"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/accounts/doctype/payment_entry/payment_entry.py +150,"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
+apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,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
@@ -5534,7 +5722,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/account.py +81,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
+DocType: Sales Invoice,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 +163,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
@@ -5564,21 +5752,23 @@
 apps/erpnext/erpnext/config/projects.py +13,Project master.,Project húsbóndi.
 apps/erpnext/erpnext/controllers/status_updater.py +209,"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 +491, (Half Day),(Hálfur dagur)
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431, (Half Day),(Hálfur dagur)
 DocType: Payment Term,Credit Days,Credit Days
+apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145,Please select Patient to get Lab Tests,Vinsamlegast veldu Sjúklingur til að fá Lab Tests
 apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Gera Student Hópur
 DocType: Fee Schedule,FRQ.,FRQ.
 DocType: Leave Type,Is Carry Forward,Er bera fram
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +840,Get Items from BOM,Fá atriði úr BOM
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841,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
+DocType: Cash Flow Mapping,Is Income Tax Expense,Er tekjuskattur kostnaður
 apps/erpnext/erpnext/controllers/accounts_controller.py +620,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}
 DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Kannaðu þetta ef nemandi er búsettur í gistihúsinu.
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Vinsamlegast sláðu sölu skipunum í töflunni hér að ofan
 ,Stock Summary,Stock Yfirlit
-apps/erpnext/erpnext/config/assets.py +50,Transfer an asset from one warehouse to another,Flytja eign frá einu vöruhúsi til annars
+apps/erpnext/erpnext/config/assets.py +54,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/doctype/journal_entry/journal_entry.py +105,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)
@@ -5586,7 +5776,7 @@
 DocType: Expense Claim Detail,Sanctioned Amount,bundnar Upphæð
 DocType: Item,Shelf Life In Days,Geymsluþol á dögum
 DocType: GL Entry,Is Opening,er Opnun
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +194,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/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}
 DocType: Journal Entry,Subscription Section,Áskriftarspurning
 apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account {0} does not exist,Reikningur {0} er ekki til
 DocType: Training Event,Training Program,Þjálfunaráætlun
