diff --git a/erpnext/translations/ro.csv b/erpnext/translations/ro.csv
index 6306b58..cf444a3 100644
--- a/erpnext/translations/ro.csv
+++ b/erpnext/translations/ro.csv
@@ -1,6 +1,5 @@
 DocType: Employee,Salary Mode,Mod de salariu
 DocType: Employee,Divorced,Divorțat/a
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +84,Warning: Same item has been entered multiple times.,Atenție: Same articol a fost introdus de mai multe ori.
 apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +96,Items already synced,Articole deja sincronizate
 DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Permiteți Element care trebuie adăugate mai multe ori într-o tranzacție
 apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Anulează Stivuitoare Vizitați {0} înainte de a anula acest revendicarea Garanție
@@ -21,6 +20,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +193,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Oprit comandă de producție nu poate fi anulat, acesta unstop întâi pentru a anula"
 DocType: Vehicle Service,Mileage,distanță parcursă
 apps/erpnext/erpnext/accounts/doctype/asset/asset.js +231,Do you really want to scrap this asset?,Chiar vrei să resturi acest activ?
+DocType: Item,Manufacturer Part Numbers,Numere Numarul de piesa
 apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +48,Select Default Supplier,Selectați Furnizor implicit
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Moneda este necesară pentru lista de prețuri {0}
 DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Va fi calculat în cadrul tranzacției.
@@ -46,23 +46,28 @@
 apps/erpnext/erpnext/templates/pages/projects.js +63,Show open,Afișați deschis
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Series Updated Successfully,Seria Actualizat cu succes
 apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +18,Checkout,Verifică
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +179,Accural Journal Entry Submitted,Accural Jurnal de intrare Introdus
 DocType: Pricing Rule,Apply On,Se aplică pe
 DocType: Item Price,Multiple Item prices.,Mai multe prețuri element.
 ,Purchase Order Items To Be Received,Achiziția comandă elementele de încasat
 DocType: SMS Center,All Supplier Contact,Toate contactele furnizorului
+DocType: Support Settings,Support Settings,Setări de sprijin
+DocType: SMS Parameter,Parameter,Parametru
 apps/erpnext/erpnext/projects/doctype/project/project.py +62,Expected End Date can not be less than Expected Start Date,Așteptat Data de încheiere nu poate fi mai mică de Data de începere așteptată
-apps/erpnext/erpnext/utilities/transaction_base.py +107,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Rata trebuie să fie aceeași ca și {1}: {2} ({3} / {4})
+apps/erpnext/erpnext/utilities/transaction_base.py +106,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Row # {0}: Rata trebuie să fie aceeași ca și {1}: {2} ({3} / {4})
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +282,New Leave Application,Noua cerere de concediu
+,Batch Item Expiry Status,Lot Articol Stare de expirare
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +146,Bank Draft,Ciorna bancară
 DocType: Mode of Payment Account,Mode of Payment Account,Modul de cont de plăți
 apps/erpnext/erpnext/stock/doctype/item/item.js +58,Show Variants,Arată Variante
 DocType: Academic Term,Academic Term,termen academic
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Material
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +614,Quantity,Cantitate
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +533,Accounts table cannot be blank.,Planul de conturi nu poate fi gol.
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +665,Quantity,Cantitate
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,Accounts table cannot be blank.,Planul de conturi nu poate fi gol.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Loans (Liabilities),Imprumuturi (Raspunderi)
 DocType: Employee Education,Year of Passing,Ani de la promovarea
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: %s, Item Code: %s and Customer: %s","Referință:% s, Postul Cod:% s și Client:% s"
+DocType: Item,Country of Origin,Tara de origine
 apps/erpnext/erpnext/templates/form_grid/stock_entry_grid.html +26,In Stock,În Stoc
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Probleme deschise
 DocType: Production Plan Item,Production Plan Item,Planul de producție Articol
@@ -70,17 +75,19 @@
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +31,Health Care,Servicii de Sanatate
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Întârziere de plată (zile)
 apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +25,Service Expense,Cheltuieli de serviciu
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +753,Invoice,Factură
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +804,Invoice,Factură
 DocType: Maintenance Schedule Item,Periodicity,Periodicitate
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Anul fiscal {0} este necesară
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +54,Expected Delivery Date is be before Sales Order Date,Data estimată de livrare este înainte de a fi comandă de vânzări Data
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +21,Defense,Apărare
 DocType: Salary Component,Abbr,Presc
 DocType: Appraisal Goal,Score (0-5),Scor (0-5)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +218,Row {0}: {1} {2} does not match with {3},Rând {0}: {1} {2} nu se potrivește cu {3}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +213,Row {0}: {1} {2} does not match with {3},Rând {0}: {1} {2} nu se potrivește cu {3}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +75,Row # {0}:,
 DocType: Timesheet,Total Costing Amount,Suma totală Costing
 DocType: Delivery Note,Vehicle No,Vehicul Nici
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +150,Please select Price List,Vă rugăm să selectați lista de prețuri
+apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Row # {0}: Document de plată este necesară pentru a finaliza trasaction
 DocType: Production Order Operation,Work In Progress,Lucrări în curs
 apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +13,Please select date,Vă rugăm să selectați data
 DocType: Employee,Holiday List,Lista de Vacanță
@@ -88,17 +95,20 @@
 DocType: Cost Center,Stock User,Stoc de utilizare
 DocType: Company,Phone No,Nu telefon
 apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +49,Course Schedules created:,Orarele de curs creat:
-apps/erpnext/erpnext/controllers/recurring_document.py +132,New {0}: #{1},Nou {0}: # {1}
+apps/erpnext/erpnext/controllers/recurring_document.py +135,New {0}: #{1},Nou {0}: # {1}
 ,Sales Partners Commission,Agent vânzări al Comisiei
 apps/erpnext/erpnext/hr/doctype/salary_component/salary_component.py +21,Abbreviation cannot have more than 5 characters,Prescurtarea nu poate contine mai mult de 5 caractere
 DocType: Payment Request,Payment Request,Cerere de plata
 DocType: Asset,Value After Depreciation,Valoarea după amortizare
 DocType: Employee,O+,O +
 apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt_dashboard.py +17,Related,Legate de
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance date can not be less than employee's joining date,Data de prezență nu poate fi mai mică decât data aderării angajatului
+DocType: Grading Scale,Grading Scale Name,Standard Nume Scala
 apps/erpnext/erpnext/accounts/doctype/account/account.js +26,This is a root account and cannot be edited.,Acesta este un cont de rădăcină și nu pot fi editate.
 DocType: BOM,Operations,Operatii
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Nu se poate seta autorizare pe baza de Discount pentru {0}
 DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Atașați fișier .csv cu două coloane, una pentru denumirea veche și unul pentru denumirea nouă"
+apps/erpnext/erpnext/accounts/utils.py +74,{0} {1} not in any active Fiscal Year.,{0} {1} nu se gaseste in niciun an fiscal activ.
 DocType: Packed Item,Parent Detail docname,Părinte Detaliu docname
 apps/erpnext/erpnext/public/js/setup_wizard.js +303,Kg,Kg
 DocType: Student Log,Log,Buturuga
@@ -109,7 +119,7 @@
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,Aceeași societate este înscris de mai multe ori
 DocType: Employee,Married,Căsătorit
 apps/erpnext/erpnext/accounts/party.py +38,Not permitted for {0},Nu este permisă {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +566,Get items from,Obține elemente din
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +556,Get items from,Obține elemente din
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +413,Stock cannot be updated against Delivery Note {0},Stock nu poate fi actualizat împotriva livrare Nota {0}
 apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produs {0}
 DocType: Payment Reconciliation,Reconcile,Reconcilierea
@@ -117,9 +127,11 @@
 DocType: Quality Inspection Reading,Reading 1,Reading 1
 DocType: Process Payroll,Make Bank Entry,Asigurați-Bank intrare
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +40,Pension Funds,Fondurile de pensii
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +87,Next Depreciation Date cannot be before Purchase Date,În continuare Amortizarea Data nu poate fi înainte Data achiziției
 DocType: SMS Center,All Sales Person,Toate persoanele de vânzăril
 DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,** Lunar Distribuție ** vă ajută să distribuie bugetul / Target peste luni dacă aveți sezonier în afacerea dumneavoastră.
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +172,Salary Structure Missing,Structura de salarizare lipsă
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1598,Not items found,Nu au fost găsite articole
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178,Salary Structure Missing,Structura de salarizare lipsă
 DocType: Lead,Person Name,Nume persoană
 DocType: Sales Invoice Item,Sales Invoice Item,Factură de vânzări Postul
 DocType: Account,Credit,Credit
@@ -136,6 +148,7 @@
 DocType: BOM,Item Image (if not slideshow),Imagine Articol (dacă nu exista prezentare)
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,An Customer exists with same name,Există un client cu același nume
 DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Tarif orar / 60) * Timp efectiv de operare
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +892,Select BOM,Selectați BOM
 DocType: SMS Log,SMS Log,SMS Conectare
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Costul de articole livrate
 apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Vacanta pe {0} nu este între De la data si pana in prezent
@@ -147,15 +160,18 @@
 DocType: Item,Copy From Item Group,Copiere din Grupul de Articole
 DocType: Journal Entry,Opening Entry,Deschiderea de intrare
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Contul Plătiți numai
+DocType: Employee Loan,Repay Over Number of Periods,Rambursa Peste Număr de Perioade
 DocType: Stock Entry,Additional Costs,Costuri suplimentare
 apps/erpnext/erpnext/accounts/doctype/account/account.py +142,Account with existing transaction can not be converted to group.,Un cont cu tranzacții existente nu poate fi transformat în grup.
 DocType: Lead,Product Enquiry,Intrebare produs
 DocType: Academic Term,Schools,școli
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Nici o înregistrare de concediu găsite pentru angajat {0} pentru {1}
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Va rugam sa introduceti prima companie
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +333,Please select Company first,Vă rugăm să selectați Company primul
 DocType: Employee Education,Under Graduate,Sub Absolvent
 apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Țintă pe
 DocType: BOM,Total Cost,Cost total
+DocType: Journal Entry Account,Employee Loan,angajat de împrumut
 apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.js +89,Activity Log:,Jurnal Activitati:
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +227,Item {0} does not exist in the system or has expired,Articolul {0} nu există în sistem sau a expirat
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +44,Real Estate,Imobiliare
@@ -175,16 +191,20 @@
 DocType: Training Result Employee,Grade,calitate
 DocType: Sales Invoice Item,Delivered By Supplier,Livrate de Furnizor
 DocType: SMS Center,All Contact,Toate contactele
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +880,Production Order already created for all items with BOM,Comanda de producție deja creat pentru toate elementele cu BOM
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +182,Annual Salary,Salariu anual
 DocType: Daily Work Summary,Daily Work Summary,Sumar zilnic de lucru
 DocType: Period Closing Voucher,Closing Fiscal Year,Închiderea Anului Fiscal
 apps/erpnext/erpnext/accounts/party.py +347,{0} {1} is frozen,{0} {1} este blocat
 apps/erpnext/erpnext/setup/doctype/company/company.py +131,Please select Existing Company for creating Chart of Accounts,Vă rugăm să selectați Companie pentru crearea Existent Plan de conturi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +78,Stock Expenses,Cheltuieli stoc
+apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Vă rugăm să introduceți preferate Contact E-mail
 DocType: Journal Entry,Contra Entry,Contra intrare
 DocType: Journal Entry Account,Credit in Company Currency,Credit în companie valutar
 DocType: Delivery Note,Installation Status,Starea de instalare
-apps/erpnext/erpnext/controllers/buying_controller.py +320,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Cant acceptată + respinsă trebuie să fie egală cu cantitatea recepționată pentru articolul {0}
+apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +125,"Do you want to update attendance?<br>Present: {0}\
+					<br>Absent: {1}",Doriți să actualizați prezență? <br> Prezent: {0} \ <br> Absent: {1}
+apps/erpnext/erpnext/controllers/buying_controller.py +321,Accepted + Rejected Qty must be equal to Received quantity for Item {0},Cant acceptată + respinsă trebuie să fie egală cu cantitatea recepționată pentru articolul {0}
 DocType: Request for Quotation,RFQ-,RFQ-
 DocType: Item,Supply Raw Materials for Purchase,Materii prime de alimentare pentru cumparare
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +131,At least one mode of payment is required for POS invoice.,Cel puțin un mod de plată este necesară pentru POS factură.
@@ -195,7 +215,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +471,Item {0} is not active or end of life has been reached,Articolul {0} nu este activ sau sfarsitul ciclului sau de viata a fost atins
 apps/erpnext/erpnext/public/js/setup_wizard.js +346,Example: Basic Mathematics,Exemplu: matematică de bază
 apps/erpnext/erpnext/controllers/accounts_controller.py +663,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Pentru a include taxa în rândul {0} în rata articol, impozitele în rânduri {1} trebuie de asemenea să fie incluse"
-apps/erpnext/erpnext/config/hr.py +197,Settings for HR Module,Setările pentru modul HR
+apps/erpnext/erpnext/config/hr.py +214,Settings for HR Module,Setările pentru modul HR
 DocType: SMS Center,SMS Center,SMS Center
 DocType: Sales Invoice,Change Amount,Sumă schimbare
 DocType: BOM Replace Tool,New BOM,Nou BOM
@@ -207,13 +227,14 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +153,Execution,Executie
 apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Detalii privind operațiunile efectuate.
 DocType: Serial No,Maintenance Status,Stare Mentenanta
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +57,{0} {1}: Supplier is required against Payable account {2},{0} {1}: furnizor este necesară împotriva contului de plati {2}
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +57,{0} {1}: Supplier is required against Payable account {2},{0} {1}: furnizor este necesar împotriva contului de plati {2}
 apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Articole și Prețuri
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Numărul total de ore: {0}
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},De la data trebuie să fie în anul fiscal. Presupunând că la data = {0}
 DocType: Customer,Individual,Individual
 DocType: Interest,Academics User,cadre universitare utilizator
 DocType: Cheque Print Template,Amount In Figure,Suma în Figura
+DocType: Employee Loan Application,Loan Info,Creditul Info
 apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Planul de de vizite de întreținere.
 DocType: SMS Settings,Enter url parameter for message,Introduceți parametru url pentru mesaj
 DocType: POS Profile,Customer Groups,grupurile de clienti
@@ -231,17 +252,20 @@
 apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Alocaţi concedii anuale.
 DocType: SG Creation Tool Course,SG Creation Tool Course,SG Creare curs Unealtă
 DocType: Student Group Creation Tool,Leave blank if you wish to fetch all courses for selected academic term,Lasă un gol dacă doriți să preluați toate cursurile pentru termen academice selectate
-apps/erpnext/erpnext/controllers/selling_controller.py +168,Selling price for item {0} is lower than its {1}. Selling price should be atleast {2},Prețul pentru elementul de vânzare {0} este mai mică decât sa {1}. Prețul de vânzare ar trebui să fie atleast {2}
+apps/erpnext/erpnext/controllers/selling_controller.py +177,Selling price for item {0} is lower than its {1}. Selling price should be atleast {2},Prețul pentru elementul de vânzare {0} este mai mică decât sa {1}. Prețul de vânzare ar trebui să fie atleast {2}
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +227,Insufficient Stock,stoc insuficient
 DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Planificarea Capacitatii Dezactivați și Time Tracking
 DocType: Email Digest,New Sales Orders,Noi comenzi de vânzări
 DocType: Bank Reconciliation,Bank Account,Cont bancar
 DocType: Leave Type,Allow Negative Balance,Permiteţi sold negativ
+DocType: Employee,Create User,Creaza utilizator
 DocType: Selling Settings,Default Territory,Teritoriu Implicit
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +53,Television,Televiziune
 DocType: Production Order Operation,Updated via 'Time Log',"Actualizat prin ""Ora Log"""
 apps/erpnext/erpnext/controllers/taxes_and_totals.py +414,Advance amount cannot be greater than {0} {1},Suma avans nu poate fi mai mare decât {0} {1}
 DocType: Naming Series,Series List for this Transaction,Lista de serie pentru această tranzacție
+DocType: Company,Default Payroll Payable Account,Implicit Salarizare cont de plati
+apps/erpnext/erpnext/schools/doctype/student_batch/student_batch.js +7,Update Email Group,Actualizare e-mail Group
 DocType: Sales Invoice,Is Opening Entry,Deschiderea este de intrare
 DocType: Customer Group,Mention if non-standard receivable account applicable,Menționa dacă non-standard de cont primit aplicabil
 DocType: Course Schedule,Instructor Name,Nume instructor
@@ -253,13 +277,14 @@
 DocType: Delivery Note Item,Against Sales Invoice Item,Comparativ articolului facturii de vânzări
 ,Production Orders in Progress,Comenzile de producție în curs de desfășurare
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +39,Net Cash from Financing,Numerar net din Finantare
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1818,"LocalStorage is full , did not save","LocalStorage este plin, nu a salvat"
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2179,"LocalStorage is full , did not save","LocalStorage este plin, nu a salvat"
 DocType: Lead,Address & Contact,Adresă și contact
 DocType: Leave Allocation,Add unused leaves from previous allocations,Adauga frunze neutilizate de alocări anterioare
-apps/erpnext/erpnext/controllers/recurring_document.py +227,Next Recurring {0} will be created on {1},Urmatoarea recurent {0} va fi creat pe {1}
+apps/erpnext/erpnext/controllers/recurring_document.py +230,Next Recurring {0} will be created on {1},Urmatoarea recurent {0} va fi creat pe {1}
 DocType: Sales Partner,Partner website,site-ul partenerului
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +105,Add Item,Adaugare element
 ,Contact Name,Nume Persoana de Contact
+DocType: Course Assessment Criteria,Course Assessment Criteria,Criterii de evaluare a cursului
 DocType: Process Payroll,Creates salary slip for above mentioned criteria.,Creare fluturas de salariu pentru criteriile mentionate mai sus.
 DocType: POS Customer Group,POS Customer Group,POS Clienți Grupul
 DocType: Cheque Print Template,Line spacing for amount in words,distanța dintre rânduri pentru suma în cuvinte
@@ -267,11 +292,11 @@
 apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Nici o descriere dat
 apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Cere pentru cumpărare.
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Aceasta se bazează pe fișele de pontaj create împotriva acestui proiect
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +351,Net Pay cannot be less than 0,Plata netă nu poate fi mai mică decât 0
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +371,Net Pay cannot be less than 0,Plata netă nu poate fi mai mică decât 0
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +224,Only the selected Leave Approver can submit this Leave Application,Numai selectat concediu aprobator poate înainta această aplicație Leave
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +116,Relieving Date must be greater than Date of Joining,Alinarea Data trebuie să fie mai mare decât Data aderării
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +190,Leaves per Year,Frunze pe an
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +123,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Rând {0}: Vă rugăm să verificați ""Este Advance"" împotriva Cont {1} dacă aceasta este o intrare în avans."
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,"Rând {0}: Vă rugăm să verificați ""Este Advance"" împotriva Cont {1} dacă aceasta este o intrare în avans."
 apps/erpnext/erpnext/stock/utils.py +189,Warehouse {0} does not belong to company {1},Depozit {0} nu aparține companiei {1}
 DocType: Email Digest,Profit & Loss,Pierderea profitului
 apps/erpnext/erpnext/public/js/setup_wizard.js +304,Litre,Litru
@@ -293,24 +318,26 @@
 DocType: Pricing Rule,Supplier Type,Furnizor Tip
 DocType: Course Scheduling Tool,Course Start Date,Data începerii cursului
 ,Student Batch-Wise Attendance,Lot-înțelept elev Participarea
+DocType: POS Profile,Allow user to edit Rate,Permite utilizatorului să editeze Tarif
 DocType: Item,Publish in Hub,Publica in Hub
 DocType: Student Admission,Student Admission,Admiterea studenților
 ,Terretory,Terretory
 apps/erpnext/erpnext/stock/doctype/item/item.py +710,Item {0} is cancelled,Articolul {0} este anulat
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +826,Material Request,Cerere de material
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +877,Material Request,Cerere de material
 DocType: Bank Reconciliation,Update Clearance Date,Actualizare Clearance Data
 DocType: Item,Purchase Details,Detalii de cumpărare
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +348,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Postul {0} nu a fost găsit în &quot;Materii prime furnizate&quot; masă în Comandă {1}
 DocType: Employee,Relation,Relație
 DocType: Shipping Rule,Worldwide Shipping,Expediere
 DocType: Student Guardian,Mother,Mamă
+apps/erpnext/erpnext/accounts/doctype/account/account.py +191,Account balance ({0}) and stock value ({1}) must be same,soldul contului ({0}) și valoarea stoc ({1}) trebuie să fie aceeași
 apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Comenzi confirmate de la clienți.
 DocType: Purchase Receipt Item,Rejected Quantity,Respins Cantitate
 DocType: SMS Settings,SMS Sender Name,SMS Sender Name
 DocType: Notification Control,Notification Control,Controlul notificare
 DocType: Lead,Suggestions,Sugestii
 DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,"Set bugetelor Grupa înțelept Articol de pe acest teritoriu. Puteți include, de asemenea, sezonier prin setarea distribuție."
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +269,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plata împotriva {0} {1} nu poate fi mai mare decât Impresionant Suma {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +264,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Plata împotriva {0} {1} nu poate fi mai mare decât Impresionant Suma {2}
 DocType: Supplier,Address HTML,Adresă HTML
 DocType: Lead,Mobile No.,Numar de mobil
 DocType: Maintenance Schedule,Generate Schedule,Generează orar
@@ -319,6 +346,7 @@
 DocType: Student Group Student,Student Group Student,Student Group Student
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Ultimul
 DocType: Vehicle Service,Inspection,Inspecţie
+apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +56,Student {0}: {1} does not belong to Student Batch {2},Student {0}: {1} nu aparține Lot Student {2}
 DocType: Email Digest,New Quotations,Noi Citatele
 DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,alunecare email-uri salariul angajatului în funcție de e-mail preferat selectat în Angajat
 DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,Primul Aprobatorul Lăsați în lista va fi setat ca implicit concediu aprobator
@@ -327,18 +355,20 @@
 DocType: Asset,Next Depreciation Date,Amortizarea următor Data
 apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Activitatea de Cost per angajat
 DocType: Accounts Settings,Settings for Accounts,Setări pentru conturi
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +635,Supplier Invoice No exists in Purchase Invoice {0},Furnizor Factura nr există în factură Purchase {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +643,Supplier Invoice No exists in Purchase Invoice {0},Furnizor Factura nr există în factură Purchase {0}
 apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Gestioneaza Ramificatiile Persoanei responsabila cu Vanzarile
 DocType: Job Applicant,Cover Letter,Scrisoare de intenție
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Cecuri restante și pentru a șterge Depozite
 DocType: Item,Synced With Hub,Sincronizat cu Hub
 DocType: Vehicle,Fleet Manager,Manager de flotă
-apps/erpnext/erpnext/setup/doctype/company/company.js +63,Wrong Password,Parola Gresita
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +505,Row #{0}: {1} can not be negative for item {2},Row # {0}: {1} nu poate fi negativ pentru elementul {2}
+apps/erpnext/erpnext/setup/doctype/company/company.js +64,Wrong Password,Parola Gresita
 DocType: Item,Variant Of,Varianta de
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +349,Completed Qty can not be greater than 'Qty to Manufacture',"Finalizat Cantitate nu poate fi mai mare decât ""Cantitate de Fabricare"""
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +367,Completed Qty can not be greater than 'Qty to Manufacture',"Finalizat Cantitate nu poate fi mai mare decât ""Cantitate de Fabricare"""
 DocType: Period Closing Voucher,Closing Account Head,Închidere Cont Principal
 DocType: Employee,External Work History,Istoricul lucrului externă
 apps/erpnext/erpnext/projects/doctype/task/task.py +99,Circular Reference Error,Eroare de referință Circular
+apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49,Guardian1 Name,Nume Guardian1
 DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,În cuvinte (de export) va fi vizibil după ce a salva de livrare Nota.
 DocType: Cheque Print Template,Distance from left edge,Distanța de la marginea din stânga
 apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} unități de [{1}] (# Forma / Postul / {1}) găsit în [{2}] (# Forma / Depozit / {2})
@@ -347,11 +377,12 @@
 DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Notifica prin e-mail la crearea de cerere automată Material
 DocType: Journal Entry,Multi Currency,Multi valutar
 DocType: Payment Reconciliation Invoice,Invoice Type,Factura Tip
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +835,Delivery Note,Nota de Livrare
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +841,Delivery Note,Nota de Livrare
 apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Configurarea Impozite
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +131,Cost of Sold Asset,Costul de active vândute
 apps/erpnext/erpnext/accounts/utils.py +349,Payment Entry has been modified after you pulled it. Please pull it again.,Plata intrare a fost modificat după ce-l tras. Vă rugăm să trage din nou.
 apps/erpnext/erpnext/stock/doctype/item/item.py +440,{0} entered twice in Item Tax,{0} a fost introdus de două ori în taxa articolului
+DocType: Grade Interval,Min Score,min Scor
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +114,Summary for this week and pending activities,Rezumat pentru această săptămână și a activităților în curs
 DocType: Student Applicant,Admitted,A recunoscut că
 DocType: Workstation,Rent Cost,Chirie Cost
@@ -364,25 +395,25 @@
 DocType: Shipping Rule,Valid for Countries,Valabil pentru țările
 apps/erpnext/erpnext/stock/doctype/item/item.js +57,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,"Acest post este un șablon și nu pot fi folosite în tranzacții. Atribute articol vor fi copiate pe în variantele cu excepția cazului în este setat ""Nu Copy"""
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Comanda total Considerat
-apps/erpnext/erpnext/config/hr.py +217,"Employee designation (e.g. CEO, Director etc.).","Desemnare angajat (de exemplu, CEO, director, etc)."
-apps/erpnext/erpnext/controllers/recurring_document.py +220,Please enter 'Repeat on Day of Month' field value,"Va rugam sa introduceti ""Repeat la zi a lunii"" valoare de câmp"
+apps/erpnext/erpnext/config/hr.py +234,"Employee designation (e.g. CEO, Director etc.).","Desemnare angajat (de exemplu, CEO, director, etc)."
+apps/erpnext/erpnext/controllers/recurring_document.py +223,Please enter 'Repeat on Day of Month' field value,"Va rugam sa introduceti ""Repeat la zi a lunii"" valoare de câmp"
 DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Rata la care Clientul valuta este convertită în valuta de bază a clientului
 DocType: Course Scheduling Tool,Course Scheduling Tool,Instrument curs de programare
 apps/erpnext/erpnext/controllers/accounts_controller.py +564,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Rând # {0}: Achiziția Factura nu poate fi făcută împotriva unui activ existent {1}
 DocType: Item Tax,Tax Rate,Cota de impozitare
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} deja alocate pentru Angajat {1} pentru perioada {2} {3} pentru a
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +794,Select Item,Selectați articol
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +845,Select Item,Selectați articol
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +151,"Item: {0} managed batch-wise, can not be reconciled using \
 					Stock Reconciliation, instead use Stock Entry","Postul: {0} în șarje, nu pot fi reconciliate cu ajutorul \
  stoc reconciliere, utilizați în schimb stoc intrare gestionate"
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +139,Purchase Invoice {0} is already submitted,Factura de cumpărare {0} este deja depusă
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +140,Purchase Invoice {0} is already submitted,Factura de cumpărare {0} este deja depusă
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Batch No must be same as {1} {2},Row # {0}: Lot nr trebuie să fie aceeași ca și {1} {2}
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Converti la non-Group
 apps/erpnext/erpnext/config/stock.py +122,Batch (lot) of an Item.,Lotul (lot) unui articol.
 DocType: C-Form Invoice Detail,Invoice Date,Data facturii
 DocType: GL Entry,Debit Amount,Suma debit
 apps/erpnext/erpnext/accounts/party.py +239,There can only be 1 Account per Company in {0} {1},Nu poate fi doar un cont per companie în {0} {1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +367,Please see attachment,Vă rugăm să consultați atașament
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +387,Please see attachment,Vă rugăm să consultați atașament
 DocType: Purchase Order,% Received,% Primit
 apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Creați Grupurile de studenți
 apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +21,Setup Already Complete!!,Setup deja complet!
@@ -391,6 +422,7 @@
 DocType: Quality Inspection,Inspected By,Inspectat de
 DocType: Maintenance Visit,Maintenance Type,Tip Mentenanta
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},Serial No {0} nu aparține de livrare Nota {1}
+apps/erpnext/erpnext/templates/pages/demo.html +55,ERPNext Demo,ERPNext Demo
 apps/erpnext/erpnext/public/js/utils/item_selector.js +12,Add Items,Adăugarea de elemente
 DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Parametru Inspecție de Calitate Articol
 DocType: Leave Application,Leave Approver Name,Lăsați Nume aprobator
@@ -407,8 +439,9 @@
 DocType: Request for Quotation,Request for Quotation,Cerere de ofertă
 DocType: Salary Slip Timesheet,Working Hours,Ore de lucru
 DocType: Naming Series,Change the starting / current sequence number of an existing series.,Schimbați secventa de numar de inceput / curent a unei serii existente.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1335,Create a new Customer,Creați un nou client
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +57,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","În cazul în care mai multe reguli de stabilire a prețurilor continuă să prevaleze, utilizatorii sunt rugați să setați manual prioritate pentru a rezolva conflictul."
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +713,Purchase Return,Înapoi cumpărare
+apps/erpnext/erpnext/utilities/activation.py +91,Create Purchase Orders,Creare comenzi de aprovizionare
 ,Purchase Register,Cumpărare Inregistrare
 DocType: Course Scheduling Tool,Rechedule,Rechedule
 DocType: Landed Cost Item,Applicable Charges,Taxe aplicabile
@@ -417,19 +450,20 @@
 DocType: Purchase Receipt,Vehicle Date,Vehicul Data
 DocType: Student Log,Medical,Medical
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +180,Reason for losing,Motiv pentru a pierde
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Plumb Proprietarul nu poate fi aceeași ca de plumb
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +41,Lead Owner cannot be same as the Lead,Plumb Proprietarul nu poate fi aceeași ca de plumb
 apps/erpnext/erpnext/accounts/utils.py +355,Allocated amount can not greater than unadjusted amount,Suma alocată poate nu este mai mare decât valoarea brută
 DocType: Announcement,Receiver,Receptor
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Workstation este închis la următoarele date ca pe lista de vacanta: {0}
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Oportunitati
 DocType: Employee,Single,Celibatar
+DocType: Salary Slip,Total Loan Repayment,Rambursarea totală a creditului
 DocType: Account,Cost of Goods Sold,Cost Bunuri Vândute
 DocType: Purchase Invoice,Yearly,Anual
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,Please enter Cost Center,Va rugam sa introduceti Cost Center
 DocType: Journal Entry Account,Sales Order,Comandă de vânzări
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Avg. Selling Rate,Rată de vânzare medie
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Avg. Selling Rate,Rată de vânzare medie
 DocType: Assessment Plan,Examiner Name,Nume examinator
-apps/erpnext/erpnext/utilities/transaction_base.py +149,Quantity cannot be a fraction in row {0},Cantitatea nu poate fi o fracțiune în rând {0}
+apps/erpnext/erpnext/utilities/transaction_base.py +148,Quantity cannot be a fraction in row {0},Cantitatea nu poate fi o fracțiune în rând {0}
 DocType: Purchase Invoice Item,Quantity and Rate,Cantitatea și rata
 DocType: Delivery Note,% Installed,% Instalat
 apps/erpnext/erpnext/public/js/setup_wizard.js +383,Classrooms/ Laboratories etc where lectures can be scheduled.,"Classrooms / Laboratoare, etc, unde prelegeri pot fi programate."
@@ -456,12 +490,13 @@
 apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Maestru de vacanta.
 DocType: Request for Quotation Item,Required Date,Date necesare
 DocType: Delivery Note,Billing Address,Adresa de facturare
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +817,Please enter Item Code.,Vă rugăm să introduceți Cod produs.
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +873,Please enter Item Code.,Vă rugăm să introduceți Cod produs.
 DocType: BOM,Costing,Cost
 DocType: Tax Rule,Billing County,Județ facturare
 DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","In cazul in care se bifeaza, suma taxelor va fi considerată ca fiind deja inclusa în Rata de Imprimare / Suma de Imprimare"
 DocType: Request for Quotation,Message for Supplier,Mesaj pentru Furnizor
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,Raport Cantitate
+DocType: Item,Show in Website (Variant),Afișați în site-ul (Variant)
 DocType: Employee,Health Concerns,Probleme de Sanatate
 DocType: Process Payroll,Select Payroll Period,Perioada de selectare Salarizare
 DocType: Purchase Invoice,Unpaid,Neachitat
@@ -475,6 +510,7 @@
 apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Record de prezenţă.
 DocType: Salary Structure,Salary Component for timesheet based payroll.,Componenta de salarizare pentru salarizare bazate pe timesheet.
 DocType: Sales Order Item,Used for Production Plan,Folosit pentru Planul de producție
+DocType: Employee Loan,Total Payment,Plată totală
 DocType: Manufacturing Settings,Time Between Operations (in mins),Timp între operațiuni (în minute)
 DocType: Customer,Buyer of Goods and Services.,Cumpărător de produse și servicii.
 DocType: Journal Entry,Accounts Payable,Conturi de plată
@@ -482,6 +518,7 @@
 DocType: Pricing Rule,Valid Upto,Valid Până la
 DocType: Training Event,Workshop,Atelier
 apps/erpnext/erpnext/public/js/setup_wizard.js +243,List a few of your customers. They could be organizations or individuals.,Listeaza cativa din clienții dvs. Ei ar putea fi organizații sau persoane fizice.
+,Enough Parts to Build,Piese de schimb suficient pentru a construi
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Direct Income,Venituri Directe
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +36,"Can not filter based on Account, if grouped by Account","Nu se poate filtra pe baza de cont, în cazul gruparii in functie de Cont"
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +92,Administrative Officer,Ofițer administrativ
@@ -500,7 +537,7 @@
 DocType: Sales Invoice,Offline POS Name,Offline Numele POS
 DocType: Sales Order,To Deliver,A Livra
 DocType: Purchase Invoice Item,Item,Obiect
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1946,Serial no item cannot be a fraction,Serial nici un articol nu poate fi o fracție
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2342,Serial no item cannot be a fraction,Serial nici un articol nu poate fi o fracție
 DocType: Journal Entry,Difference (Dr - Cr),Diferența (Dr - Cr)
 DocType: Account,Profit and Loss,Profit și pierdere
 apps/erpnext/erpnext/config/stock.py +325,Managing Subcontracting,Gestionarea Subcontracte
@@ -520,12 +557,13 @@
 DocType: Purchase Invoice,Supplier Invoice No,Furnizor Factura Nu
 DocType: Territory,For reference,Pentru referință
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +154,"Cannot delete Serial No {0}, as it is used in stock transactions","Nu se poate șterge de serie nr {0}, așa cum este utilizat în tranzacțiile bursiere"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +242,Closing (Cr),De închidere (Cr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +245,Closing (Cr),De închidere (Cr)
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +105,Move Item,Postul mutare
 DocType: Serial No,Warranty Period (Days),Perioada de garanție (zile)
 DocType: Installation Note Item,Installation Note Item,Instalare Notă Postul
 DocType: Production Plan Item,Pending Qty,Așteptare Cantitate
 DocType: Budget,Ignore,Ignora
+apps/erpnext/erpnext/accounts/party.py +351,{0} {1} is not active,{0} {1} nu este activ
 apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +90,SMS sent to following numbers: {0},SMS expediat la următoarele numere: {0}
 apps/erpnext/erpnext/config/accounts.py +241,Setup cheque dimensions for printing,Dimensiunile de instalare pentru imprimare de verificare
 DocType: Salary Slip,Salary Slip Timesheet,Salariu alunecare Pontaj
@@ -546,6 +584,7 @@
 DocType: C-Form Invoice Detail,Grand Total,Total general
 DocType: Training Event,Course,Curs
 DocType: Timesheet,Payslip,fluturaș
+apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Cos
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,Anul fiscal Data începerii nu trebuie să fie mai mare decât anul fiscal Data de încheiere
 DocType: Issue,Resolution,Rezolutie
 DocType: C-Form,IV,IV
@@ -556,7 +595,7 @@
 DocType: Job Applicant,Resume Attachment,CV-Atașamentul
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Clienții repetate
 DocType: Leave Control Panel,Allocate,Alocaţi
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +763,Sales Return,Vânzări de returnare
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +809,Sales Return,Vânzări de returnare
 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,Notă: Totalul frunzelor alocate {0} nu ar trebui să fie mai mică decât frunzele deja aprobate {1} pentru perioada
 DocType: Announcement,Posted By,Postat de
 DocType: Item,Delivered by Supplier (Drop Ship),Livrate de Furnizor (Drop navelor)
@@ -565,21 +604,25 @@
 apps/erpnext/erpnext/config/selling.py +28,Customer database.,Baza de Date Client.
 DocType: Quotation,Quotation To,Citat Pentru a
 DocType: Lead,Middle Income,Venituri medii
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +214,Opening (Cr),Deschidere (Cr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +217,Opening (Cr),Deschidere (Cr)
 apps/erpnext/erpnext/stock/doctype/item/item.py +816,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.,"Unitatea de măsură implicită pentru postul {0} nu poate fi schimbat direct, deoarece aveti si voi deja unele tranzacții (i) cu un alt UOM. Veți avea nevoie pentru a crea un nou element pentru a utiliza un alt implicit UOM."
 apps/erpnext/erpnext/accounts/utils.py +353,Allocated amount can not be negative,Suma alocată nu poate fi negativă
 DocType: Purchase Order Item,Billed Amt,Suma facturată
 DocType: Training Result Employee,Training Result Employee,Angajat de formare Rezultat
 DocType: Warehouse,A logical Warehouse against which stock entries are made.,Un depozit logic față de care se efectuează înregistrări de stoc.
+DocType: Repayment Schedule,Principal Amount,Suma principală
+DocType: Employee Loan Application,Total Payable Interest,Dobânda totală de plată
 DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Vânzări factură Pontaj
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +111,Reference No & Reference Date is required for {0},Nu referință și de referință Data este necesar pentru {0}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +106,Reference No & Reference Date is required for {0},Nu referință și de referință Data este necesar pentru {0}
 DocType: Process Payroll,Select Payment Account to make Bank Entry,Selectați Cont de plăți pentru a face Banca de intrare
+apps/erpnext/erpnext/utilities/activation.py +137,"Create Employee records to manage leaves, expense claims and payroll","Crearea de înregistrări angajaților pentru a gestiona frunze, cheltuieli și salarizare creanțe"
 apps/erpnext/erpnext/support/doctype/issue/issue.js +24,Add to Knowledge Base,Adaugă în Baza de cunoștințe
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +152,Proposal Writing,Propunere de scriere
 DocType: Payment Entry Deduction,Payment Entry Deduction,Plată Deducerea intrare
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Un alt Sales Person {0} există cu același ID Angajat
 DocType: Production Planning Tool,"If checked, raw materials for items that are sub-contracted will be included in the Material Requests","Dacă este bifată, materiile prime pentru elementele care sunt subcontractate vor fi incluse în Cererile materiale"
 apps/erpnext/erpnext/config/accounts.py +80,Masters,Masterat
+DocType: Assessment Plan,Maximum Assessment Score,Scor maxim de evaluare
 apps/erpnext/erpnext/config/accounts.py +140,Update Bank Transaction Dates,Perioada tranzacție de actualizare Bank
 apps/erpnext/erpnext/config/projects.py +30,Time Tracking,Urmărirea timpului
 DocType: Fiscal Year Company,Fiscal Year Company,Anul fiscal companie
@@ -587,12 +630,12 @@
 DocType: Training Event,Conference,Conferinţă
 DocType: Timesheet,Billed,Facturat
 DocType: Batch,Batch Description,Descriere lot
-apps/erpnext/erpnext/accounts/utils.py +730,"Payment Gateway Account not created, please create one manually.","Plata Gateway Cont nu a fost creată, vă rugăm să creați manual unul."
-DocType: Delivery Note,Time at which items were delivered from warehouse,Timp în care obiectele au fost livrate de la depozit
+apps/erpnext/erpnext/accounts/utils.py +720,"Payment Gateway Account not created, please create one manually.","Plata Gateway Cont nu a fost creată, vă rugăm să creați manual unul."
 DocType: Sales Invoice,Sales Taxes and Charges,Taxele de vânzări și Taxe
 DocType: Employee,Organization Profile,Organizație de profil
 DocType: Student,Sibling Details,Detalii sibling
 DocType: Vehicle Service,Vehicle Service,Serviciu de vehicule
+apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,declanșează automat cererea de feedback pe baza condițiilor.
 DocType: Employee,Reason for Resignation,Motiv pentru demisie
 apps/erpnext/erpnext/config/hr.py +147,Template for performance appraisals.,Șablon pentru evaluările de performanță.
 DocType: Sales Invoice,Credit Note Issued,Nota de credit Eliberat
@@ -607,22 +650,27 @@
 DocType: Maintenance Schedule,Maintenance Schedule,Program Mentenanta
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +34,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Apoi normelor privind prețurile sunt filtrate pe baza Customer, Client Group, Territory, furnizor, furnizor de tip, Campania, Vanzari Partener etc"
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Net Change in Inventory,Schimbarea net în inventar
+apps/erpnext/erpnext/config/hr.py +157,Employee Loan Management,Managementul de împrumut Angajat
 DocType: Employee,Passport Number,Numărul de pașaport
+apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Relation with Guardian2,Relația cu Guardian2
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +86,Manager,Manager
+DocType: Payment Entry,Payment From / To,Plata De la / la
 apps/erpnext/erpnext/selling/doctype/customer/customer.py +134,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Noua limită de credit este mai mică decât valoarea curentă restante pentru client. Limita de credit trebuie să fie atleast {0}
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +258,Same item has been entered multiple times.,Same articol a fost introdus de mai multe ori.
 DocType: SMS Settings,Receiver Parameter,Receptor Parametru
 apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,'Bazat pe' și 'Grupat dupa' nu pot fi identice
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +52,Supplier &gt; Supplier Type,Furnizor&gt; Tip Furnizor
 DocType: Sales Person,Sales Person Targets,Obiective de vânzări Persoana
 DocType: Installation Note,IN-,ÎN-
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter email address,Introduceți adresa de e-mail
 DocType: Production Order Operation,In minutes,In cateva minute
 DocType: Issue,Resolution Date,Data rezoluție
-DocType: Student Batch Name,Batch Name,Nume lot
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +301,Timesheet created:,Pontajul creat:
+DocType: Program Enrollment,Batch Name,Nume lot
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +319,Timesheet created:,Pontajul creat:
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +779,Please set default Cash or Bank account in Mode of Payment {0},Vă rugăm să setați Cash implicit sau cont bancar în modul de plată {0}
 apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +20,Enroll,A se inscrie
 DocType: Selling Settings,Customer Naming By,Numire Client de catre
+DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Va arăta studentului așa cum sunt prezente Student Raport lunar de prezență
 DocType: Depreciation Schedule,Depreciation Amount,Sumă de amortizare
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Transforma in grup
 DocType: Activity Cost,Activity Type,Tip Activitate
@@ -638,14 +686,15 @@
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Consumat
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +157,{0}: {1} not found in Invoice Details table,{0}: {1} nu a fost găsit în tabelul detalii factură
 DocType: Company,Round Off Cost Center,Rotunji cost Center
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +205,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vizita de Mentenanta {0} trebuie sa fie anulată înainte de a anula această Comandă de Vânzări
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +218,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Vizita de Mentenanta {0} trebuie sa fie anulată înainte de a anula această Comandă de Vânzări
 DocType: Item,Material Transfer,Transfer de material
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +207,Opening (Dr),Deschidere (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +210,Opening (Dr),Deschidere (Dr)
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Timestamp postarea trebuie să fie după {0}
+DocType: Employee Loan,Total Interest Payable,Dobânda totală de plată
 DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Impozite cost debarcate și Taxe
 DocType: Production Order Operation,Actual Start Time,Timpul efectiv de începere
 DocType: BOM Operation,Operation Time,Funcționare Ora
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +141,Finish,finalizarea
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +134,Finish,finalizarea
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +386,Base,Baza
 DocType: Timesheet,Total Billed Hours,Numărul total de ore facturate
 DocType: Journal Entry,Write Off Amount,Scrie Off Suma
@@ -653,14 +702,16 @@
 DocType: Company,Gain/Loss Account on Asset Disposal,Cont câștig / Pierdere de eliminare a activelor
 DocType: Purchase Invoice,Quarterly,Trimestrial
 DocType: Selling Settings,Delivery Note Required,Nota de Livrare Necesara
+DocType: Assessment Criteria,Assessment Criteria,Criterii de evaluare
 DocType: BOM Item,Basic Rate (Company Currency),Rată elementară (moneda companiei)
 DocType: Student Attendance,Student Attendance,Participarea studenților
 DocType: Sales Invoice Timesheet,Time Sheet,Fișa de timp
 DocType: Manufacturing Settings,Backflush Raw Materials Based On,Backflush Materii Prime bazat pe
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +59,Please enter item details,Va rugam sa introduceti detalii element
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +60,Please enter item details,Va rugam sa introduceti detalii element
 DocType: Interest,Interest,Interes
 apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Vânzări pre
 DocType: Purchase Receipt,Other Details,Alte detalii
+apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,furnizo
 DocType: Account,Accounts,Conturi
 DocType: Vehicle,Odometer Value (Last),Valoarea contorului de parcurs (Ultimul)
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +71,Marketing,Marketing
@@ -684,12 +735,14 @@
 DocType: Material Request Item,Quantity and Warehouse,Cantitatea și Warehouse
 DocType: Sales Invoice,Commission Rate (%),Rata de Comision (%)
 DocType: Project,Estimated Cost,Cost estimat
+DocType: Purchase Order,Link to material requests,Link la cererile de materiale
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +7,Aerospace,Spaţiul aerian
 DocType: Journal Entry,Credit Card Entry,Card de credit intrare
 apps/erpnext/erpnext/config/accounts.py +51,Company and Accounts,Și evidența contabilă
 apps/erpnext/erpnext/config/stock.py +22,Goods received from Suppliers.,Bunuri primite de la furnizori.
 apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +49,In Value,în valoare
 DocType: Lead,Campaign Name,Denumire campanie
+DocType: Selling Settings,Close Opportunity After Days,Închide oportunitate După zile
 ,Reserved,Rezervat
 DocType: Purchase Order,Supply Raw Materials,Aprovizionarea cu materii prime
 DocType: Purchase Invoice,The date on which next invoice will be generated. It is generated on submit.,Data la care va fi generat următoarea factură. Acesta este generată pe prezinte.
@@ -707,7 +760,7 @@
 DocType: Employee,Cell Number,Număr Celula
 apps/erpnext/erpnext/stock/reorder_item.py +177,Auto Material Requests Generated,Cereri materiale Auto Generat
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Pierdut
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,You can not enter current voucher in 'Against Journal Entry' column,"Nu puteți introduce voucher curent în ""Împotriva Jurnalul intrare"" coloană"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +140,You can not enter current voucher in 'Against Journal Entry' column,"Nu puteți introduce voucher curent în ""Împotriva Jurnalul intrare"" coloană"
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Rezervat pentru fabricare
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +25,Energy,Energie
 DocType: Opportunity,Opportunity From,Oportunitate de la
@@ -720,10 +773,10 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +307,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Reguli de preturi multiple există cu aceleași criterii, vă rugăm să rezolve conflictul prin atribuirea de prioritate. Reguli de preț: {0}"
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +431,Cannot deactivate or cancel BOM as it is linked with other BOMs,"Nu se poate deactiva sau anula FDM, deoarece este conectat cu alte FDM-uri"
 DocType: Opportunity,Maintenance,Mentenanţă
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +207,Purchase Receipt number required for Item {0},Număr Primirea de achiziție necesar pentru postul {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,Purchase Receipt number required for Item {0},Număr Primirea de achiziție necesar pentru postul {0}
 DocType: Item Attribute Value,Item Attribute Value,Postul caracteristicii Valoarea
 apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Campanii de vanzari.
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +42,Make Timesheet,asiguraţi-Pontaj
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +48,Make Timesheet,asiguraţi-Pontaj
 DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
 
 #### Note
@@ -767,10 +820,13 @@
 DocType: Budget,Project,Proiecte
 DocType: Quality Inspection Reading,Reading 7,Lectură 7
 DocType: Expense Claim Detail,Expense Claim Type,Tip Revendicare Cheltuieli
+apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +192,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Vă rugăm să setați Naming Seria pentru {0} prin Configurare&gt; Setări&gt; Seria Naming
 DocType: Shopping Cart Settings,Default settings for Shopping Cart,Setările implicite pentru Cosul de cumparaturi
 apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +128,Asset scrapped via Journal Entry {0},Activ casate prin Jurnal de intrare {0}
+DocType: Employee Loan,Interest Income Account,Contul Interes Venit
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +13,Biotechnology,Biotehnologie
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +107,Office Maintenance Expenses,Cheltuieli de întreținere birou
+apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Configurarea contului de e-mail
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +115,Please enter Item first,Va rugam sa introduceti Articol primul
 DocType: Account,Liability,Răspundere
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +175,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Sancționat Suma nu poate fi mai mare decât revendicarea Suma în rândul {0}.
@@ -779,7 +835,7 @@
 DocType: Employee,Family Background,Context familial
 DocType: Request for Quotation Supplier,Send Email,Trimiteți-ne email
 apps/erpnext/erpnext/stock/doctype/item/item.py +205,Warning: Invalid Attachment {0},Atenție: Attachment invalid {0}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +743,No Permission,Nici o permisiune
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +744,No Permission,Nici o permisiune
 DocType: Company,Default Bank Account,Cont Bancar Implicit
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +50,"To filter based on Party, select Party Type first","Pentru a filtra pe baza Party, selectați Party Tip primul"
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},"""Actualizare stoc"" nu poate fi activat, deoarece obiectele nu sunt livrate prin {0}"
@@ -796,12 +852,14 @@
 DocType: Warehouse,Tree Details,copac Detalii
 DocType: Training Event,Event Status,Stare eveniment
 ,Support Analytics,Suport Analytics
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +339,"If you have any questions, please get back to us.","Dacă aveți întrebări, vă rugăm să ne întoarcem la noi."
 DocType: Item,Website Warehouse,Site-ul Warehouse
 DocType: Payment Reconciliation,Minimum Invoice Amount,Factură cantitate minimă
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +112,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}: Cost Center {2} nu aparține Companiei {3}
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +89,{0} {1}: Account {2} cannot be a Group,{0} {1}: Cont {2} nu poate fi un grup
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +60,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Postul rând {IDX}: {DOCTYPE} {DOCNAME} nu există în sus &quot;{DOCTYPE} &#39;masă
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +262,Timesheet {0} is already completed or cancelled,Pontajul {0} este deja finalizată sau anulată
+apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Nu există nicio sarcină
 DocType: Purchase Invoice,"The day of the month on which auto invoice will be generated e.g. 05, 28 etc",
 DocType: Asset,Opening Accumulated Depreciation,Deschidere Amortizarea Acumulate
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Scorul trebuie să fie mai mică sau egală cu 5
@@ -810,11 +868,13 @@
 apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Client și furnizor
 DocType: Student Batch Instructor,Student Batch Instructor,Instructor de student Lot
 DocType: Email Digest,Email Digest Settings,Setari Email Digest
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +341,Thank you for your business!,Vă mulțumesc pentru afacerea dvs!
 apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Interogări de suport din partea clienților.
+,Production Order Stock Report,Producție Raport de comandă stoc
 DocType: HR Settings,Retirement Age,Vârsta de pensionare
 DocType: Bin,Moving Average Rate,Rata medie mobilă
 DocType: Production Planning Tool,Select Items,Selectați Elemente
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +365,{0} against Bill {1} dated {2},{0} comparativ cu factura {1} din data de {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Bill {1} dated {2},{0} comparativ cu factura {1} din data de {2}
 apps/erpnext/erpnext/schools/doctype/course/course.js +17,Course Schedule,Program de curs de
 DocType: Maintenance Visit,Completion Status,Stare Finalizare
 DocType: HR Settings,Enter retirement age in years,Introdu o vârsta de pensionare în anii
@@ -822,7 +882,6 @@
 DocType: Cheque Print Template,Starting location from left edge,Punctul de plecare de la marginea din stânga
 DocType: Item,Allow over delivery or receipt upto this percent,Permiteți peste livrare sau primire pana la acest procent
 DocType: Stock Entry,STE-,sterilizabile
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +53,Expected Delivery Date cannot be before Sales Order Date,Data de Livrare Preconizata nu poate fi anterioara Datei Ordinului de Vanzare
 DocType: Upload Attendance,Import Attendance,Import Spectatori
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +20,All Item Groups,Toate grupurile articolului
 DocType: Process Payroll,Activity Log,Jurnal Activitate
@@ -830,11 +889,12 @@
 apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Compune în mod automat un mesaj la introducere de tranzacții.
 DocType: Production Order,Item To Manufacture,Articol pentru Fabricare
 apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +81,{0} {1} status is {2},{0} {1} statusul este {2}
+DocType: Employee,Provide Email Address registered in company,Furnizarea Adresa de email inregistrata in companie
 DocType: Shopping Cart Settings,Enable Checkout,activaţi Checkout
 apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Comandă de aprovizionare de plata
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Proiectat Cantitate
 DocType: Sales Invoice,Payment Due Date,Data scadentă de plată
-apps/erpnext/erpnext/stock/doctype/item/item.js +302,Item Variant {0} already exists with same attributes,Postul Varianta {0} există deja cu aceleași atribute
+apps/erpnext/erpnext/stock/doctype/item/item.js +340,Item Variant {0} already exists with same attributes,Postul Varianta {0} există deja cu aceleași atribute
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +95,'Opening',&quot;Deschiderea&quot;
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Deschideți To Do
 DocType: Notification Control,Delivery Note Message,Nota de Livrare Mesaj
@@ -850,6 +910,7 @@
 DocType: Item Reorder,Re-Order Qty,Re-comanda Cantitate
 DocType: Leave Block List Date,Leave Block List Date,Data Lista Concedii Blocate
 DocType: Pricing Rule,Price or Discount,Preț sau Reducere
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +75,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Taxe totale aplicabile în tabelul de achiziție Chitanță Elementele trebuie să fie la fel ca total impozite și taxe
 DocType: Sales Team,Incentives,Stimulente
 DocType: SMS Log,Requested Numbers,Numere solicitate
 DocType: Production Planning Tool,Only Obtain Raw Materials,Se obține numai Materii prime
@@ -878,21 +939,23 @@
 DocType: Supplier Quotation,Is Subcontracted,Este subcontractată
 DocType: Item Attribute,Item Attribute Values,Valori Postul Atribut
 DocType: Examination Result,Examination Result,examinarea Rezultat
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +733,Purchase Receipt,Primirea de cumpărare
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +788,Purchase Receipt,Primirea de cumpărare
 ,Received Items To Be Billed,Articole primite Pentru a fi facturat
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +177,Submitted Salary Slips,Depuse Alunecările salariale
 DocType: Employee,Ms,Ms
 apps/erpnext/erpnext/config/accounts.py +267,Currency exchange rate master.,Maestru cursului de schimb valutar.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +177,Reference Doctype must be one of {0},Referință Doctype trebuie să fie una dintre {0}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +284,Unable to find Time Slot in the next {0} days for Operation {1},Imposibilitatea de a găsi timp Slot în următorii {0} zile pentru Operațiunea {1}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +302,Unable to find Time Slot in the next {0} days for Operation {1},Imposibilitatea de a găsi timp Slot în următorii {0} zile pentru Operațiunea {1}
 DocType: Production Order,Plan material for sub-assemblies,Material Plan de subansambluri
 apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Parteneri de vânzări și teritoriu
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +86,Cannot automatically create Account as there is already stock balance in the Account. You must create a matching account before you can make an entry on this warehouse,Nu se poate crea în mod automat Contul deoarece există deja sold stoc în cont. Trebuie să creați un cont de potrivire înainte de a putea face o intrare pe acest depozit
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +507,BOM {0} must be active,BOM {0} trebuie să fie activ
 DocType: Journal Entry,Depreciation Entry,amortizare intrare
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +36,Please select the document type first,Vă rugăm să selectați tipul de document primul
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Anuleaza Vizite Material {0} înainte de a anula această Vizita de întreținere
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +209,Serial No {0} does not belong to Item {1},Serial Nu {0} nu aparține postul {1}
 DocType: Purchase Receipt Item Supplied,Required Qty,Necesar Cantitate
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +211,Warehouses with existing transaction can not be converted to ledger.,Depozite de tranzacții existente nu pot fi convertite în contabilitate.
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +223,Warehouses with existing transaction can not be converted to ledger.,Depozite de tranzacții existente nu pot fi convertite în contabilitate.
 DocType: Bank Reconciliation,Total Amount,Suma totală
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +32,Internet Publishing,Editura Internet
 DocType: Production Planning Tool,Production Orders,Comenzi de producție
@@ -903,15 +966,15 @@
 apps/erpnext/erpnext/accounts/general_ledger.py +142,Please mention Round Off Account in Company,Vă rugăm să menționați rotunji contul în companie
 DocType: Purchase Receipt,Range,Interval
 DocType: Supplier,Default Payable Accounts,Implicit conturi de plătit
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +45,Employee {0} is not active or does not exist,Angajatul {0} nu este activ sau nu există
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +47,Employee {0} is not active or does not exist,Angajatul {0} nu este activ sau nu există
 DocType: Fee Structure,Components,Componente
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +239,Please enter Asset Category in Item {0},Vă rugăm să introduceți activ Categorie la postul {0}
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +240,Please enter Asset Category in Item {0},Vă rugăm să introduceți activ Categorie la postul {0}
 apps/erpnext/erpnext/stock/doctype/item/item.py +626,Item Variants {0} updated,Postul variante {0} actualizat
 DocType: Quality Inspection Reading,Reading 6,Reading 6
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +862,Cannot {0} {1} {2} without any negative outstanding invoice,Can not {0} {1} {2} fără nici o factură negativă restante
 DocType: Purchase Invoice Advance,Purchase Invoice Advance,Factura de cumpărare în avans
 DocType: Hub Settings,Sync Now,Sincronizare acum
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +192,Row {0}: Credit entry can not be linked with a {1},Rând {0}: intrare de credit nu poate fi legat de o {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +187,Row {0}: Credit entry can not be linked with a {1},Rând {0}: intrare de credit nu poate fi legat de o {1}
 apps/erpnext/erpnext/config/accounts.py +210,Define budget for a financial year.,Definiți bugetul pentru un exercițiu financiar.
 DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Contul Bancar / de Numerar implicit va fi actualizat automat în Factura POS atunci când acest mod este selectat.
 DocType: Lead,LEAD-,CONDUCE-
@@ -922,23 +985,24 @@
 DocType: Item,Is Purchase Item,Este de cumparare Articol
 DocType: Asset,Purchase Invoice,Factura de cumpărare
 DocType: Stock Ledger Entry,Voucher Detail No,Detaliu voucher Nu
-apps/erpnext/erpnext/accounts/page/pos/pos.js +706,New Sales Invoice,Noua factură de vânzări
+apps/erpnext/erpnext/accounts/page/pos/pos.js +709,New Sales Invoice,Noua factură de vânzări
 DocType: Stock Entry,Total Outgoing Value,Valoarea totală de ieșire
 apps/erpnext/erpnext/public/js/account_tree_grid.js +225,Opening Date and Closing Date should be within same Fiscal Year,Deschiderea și data inchiderii ar trebui să fie în același an fiscal
 DocType: Lead,Request for Information,Cerere de informații
-apps/erpnext/erpnext/accounts/page/pos/pos.js +720,Sync Offline Invoices,Sincronizare offline Facturile
+apps/erpnext/erpnext/accounts/page/pos/pos.js +723,Sync Offline Invoices,Sincronizare offline Facturile
 DocType: Payment Request,Paid,Plătit
 DocType: Program Fee,Program Fee,Taxa de program
 DocType: Salary Slip,Total in words,Total în cuvinte
 DocType: Material Request Item,Lead Time Date,Data Timp Conducere
 DocType: Guardian,Guardian Name,Nume tutore
 DocType: Cheque Print Template,Has Print Format,Are Format imprimare
+DocType: Employee Loan,Sanctioned,consacrat
 apps/erpnext/erpnext/accounts/page/pos/pos.js +72, is mandatory. Maybe Currency Exchange record is not created for ,este obligatorie. Poate înregistrarea de schimb valutar nu este creeatã pentru
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +103,Row #{0}: Please specify Serial No for Item {1},Rând # {0}: Vă rugăm să specificați Nu serial pentru postul {1}
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +642,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pentru elementele &quot;produse Bundle&quot;, Warehouse, Serial No și lot nr vor fi luate în considerare de la &quot;ambalare List&quot; masa. Dacă Warehouse și Lot nr sunt aceleași pentru toate elementele de ambalaj pentru produs orice &quot;Bundle produs&quot;, aceste valori pot fi introduse în tabelul de punctul principal, valorile vor fi copiate &quot;de ambalare Lista&quot; masă."
 DocType: Job Opening,Publish on website,Publica pe site-ul
 apps/erpnext/erpnext/config/stock.py +17,Shipments to customers.,Transporturile către clienți.
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +615,Supplier Invoice Date cannot be greater than Posting Date,Furnizor Data facturii nu poate fi mai mare decât postare Data
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +623,Supplier Invoice Date cannot be greater than Posting Date,Furnizor Data facturii nu poate fi mai mare decât postare Data
 DocType: Purchase Invoice Item,Purchase Order Item,Comandă de aprovizionare Articol
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +130,Indirect Income,Venituri indirecte
 DocType: Student Attendance Tool,Student Attendance Tool,Instrumentul de student Participarea
@@ -946,7 +1010,7 @@
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Variație
 ,Company Name,Denumire Furnizor
 DocType: SMS Center,Total Message(s),Total mesaj(e)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +792,Select Item for Transfer,Selectați Element de Transfer
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +843,Select Item for Transfer,Selectați Element de Transfer
 DocType: Purchase Invoice,Additional Discount Percentage,Procentul discount suplimentar
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Vizualizați o listă cu toate filmele de ajutor
 DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,"Selectați contul șef al băncii, unde de verificare a fost depus."
@@ -954,7 +1018,7 @@
 DocType: Pricing Rule,Max Qty,Max Cantitate
 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","Rândul {0}: {1} factură nu este validă, aceasta ar putea fi anulate / nu există. \ Vă rugăm să introduceți o factură validă"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +125,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Rând {0}: Plata împotriva Vânzări / Ordinului de Procurare ar trebui să fie întotdeauna marcate ca avans
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +120,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Rând {0}: Plata împotriva Vânzări / Ordinului de Procurare ar trebui să fie întotdeauna marcate ca avans
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +16,Chemical,Chimic
 DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Default cont bancar / numerar vor fi actualizate automat în Jurnalul de intrare a salariului când este selectat acest mod.
 apps/erpnext/erpnext/schools/doctype/grading_structure/grading_structure.py +24,"The intervals for Grade Code {0} overlaps with the grade intervals for other grades. 
@@ -964,9 +1028,9 @@
 apps/erpnext/erpnext/public/js/setup_wizard.js +304,Meter,Metru
 DocType: Workstation,Electricity Cost,Cost energie electrică
 DocType: HR Settings,Don't send Employee Birthday Reminders,Nu trimiteți Memento pentru Zi de Nastere Angajat
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +113,Stock Entries,Stoc Entries
 DocType: Item,Inspection Criteria,Criteriile de inspecție
 apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Transferat
+DocType: BOM Website Item,BOM Website Item,Site-ul BOM Articol
 apps/erpnext/erpnext/public/js/setup_wizard.js +168,Upload your letter head and logo. (you can edit them later).,Încărcați capul scrisoare și logo-ul. (Le puteți edita mai târziu).
 DocType: Timesheet Detail,Bill,Factură
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +84,Next Depreciation Date is entered as past date,În continuare Amortizarea Data este introdusă ca dată rămas singur
@@ -974,17 +1038,18 @@
 DocType: SMS Center,All Lead (Open),Toate articolele de top (deschise)
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +222,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Rândul {0}: Cant nu este disponibil pentru {4} în depozit {1} în postarea momentul înscrierii ({2} {3})
 DocType: Purchase Invoice,Get Advances Paid,Obtine Avansurile Achitate
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +708,Make ,Realizare
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +763,Make ,Realizare
 DocType: Student Admission,Admission Start Date,Admitere Data de începere
 DocType: Journal Entry,Total Amount in Words,Suma totală în cuvinte
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,A aparut o eroare. Un motiv probabil ar putea fi că nu ați salvat formularul. Vă rugăm să contactați iulianolaru@ollala.ro dacă problema persistă.
 apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Cosul meu
-apps/erpnext/erpnext/controllers/selling_controller.py +157,Order Type must be one of {0},Pentru Tipul trebuie să fie una dintre {0}
+apps/erpnext/erpnext/controllers/selling_controller.py +159,Order Type must be one of {0},Pentru Tipul trebuie să fie una dintre {0}
 DocType: Lead,Next Contact Date,Următor Contact Data
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +35,Opening Qty,Deschiderea Cantitate
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +424,Please enter Account for Change Amount,Vă rugăm să introduceți cont pentru Schimbare Sumă
-DocType: Program Enrollment,Student Batch Name,Nume elev Lot
+DocType: Student Batch,Student Batch Name,Nume elev Lot
 DocType: Holiday List,Holiday List Name,Denumire Lista de Vacanță
+DocType: Repayment Schedule,Balance Loan Amount,Soldul Suma creditului
 apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Curs orar
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +186,Stock Options,Opțiuni pe acțiuni
 DocType: Journal Entry Account,Expense Claim,Revendicare Cheltuieli
@@ -998,12 +1063,13 @@
 DocType: Company,Default Terms,Termeni implicite
 DocType: Packing Slip Item,Packing Slip Item,Bonul Articol
 DocType: Purchase Invoice,Cash/Bank Account,Numerar/Cont Bancar
+apps/erpnext/erpnext/public/js/queries.js +88,Please specify a {0},Vă rugăm să specificați un {0}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Removed items with no change in quantity or value.,Articole eliminate cu nici o schimbare în cantitate sau de valoare.
 DocType: Delivery Note,Delivery To,De Livrare la
 apps/erpnext/erpnext/stock/doctype/item/item.py +649,Attribute table is mandatory,Tabelul atribut este obligatoriu
 DocType: Production Planning Tool,Get Sales Orders,Obține comenzile de vânzări
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +65,{0} can not be negative,{0} nu poate fi negativ
-apps/erpnext/erpnext/public/js/pos/pos.html +23,Discount,Reducere
+apps/erpnext/erpnext/public/js/pos/pos.html +13,Discount,Reducere
 DocType: Asset,Total Number of Depreciations,Număr total de Deprecieri
 DocType: Workstation,Wages,Salarizare
 DocType: Project,Internal,Intern
@@ -1015,14 +1081,15 @@
 DocType: Purchase Receipt,PREC-RET-,CCRP-RET-
 DocType: POS Profile,Sales Invoice Payment,Vânzări factură de plată
 DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Rezervat Warehouse în Vânzări Ordine / Produse finite Warehouse
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Selling Amount,Vanzarea Suma
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +73,Selling Amount,Vanzarea Suma
+DocType: Repayment Schedule,Interest Amount,Suma Dobânda
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +115,You are the Expense Approver for this record. Please Update the 'Status' and Save,"Sunteți aprobator cheltuieli pentru acest record. Vă rugăm Actualizați ""statutul"" și Salvare"
 DocType: Serial No,Creation Document No,Creare Document Nr.
 DocType: Issue,Issue,Problema
 DocType: Asset,Scrapped,dezmembrate
 apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account does not match with Company,Cont nu se potrivește cu Compania
 apps/erpnext/erpnext/config/stock.py +195,"Attributes for Item Variants. e.g Size, Color etc.","Atributele pentru variante articol. de exemplu  dimensiune, culoare etc."
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_dashboard.py +27,Returns,Se intoarce
+DocType: Purchase Invoice,Returns,Se intoarce
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,WIP Depozit
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +196,Serial No {0} is under maintenance contract upto {1},Serial Nu {0} este sub contract de întreținere pana {1}
 apps/erpnext/erpnext/config/hr.py +35,Recruitment,Recrutare
@@ -1037,24 +1104,27 @@
 DocType: GL Entry,Against,Comparativ
 DocType: Item,Default Selling Cost Center,Centru de Cost Vanzare Implicit
 DocType: Sales Partner,Implementation Partner,Partener de punere în aplicare
-apps/erpnext/erpnext/controllers/selling_controller.py +258,Sales Order {0} is {1},Comandă de vânzări {0} este {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1467,ZIP Code,Cod postal
+apps/erpnext/erpnext/controllers/selling_controller.py +268,Sales Order {0} is {1},Comandă de vânzări {0} este {1}
 DocType: Opportunity,Contact Info,Informaţii Persoana de Contact
 apps/erpnext/erpnext/config/stock.py +310,Making Stock Entries,Efectuarea de stoc Entries
 DocType: Packing Slip,Net Weight UOM,Greutate neta UOM
 apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +18,{0} Results,{0} Rezultate
 DocType: Item,Default Supplier,Furnizor Implicit
 DocType: Manufacturing Settings,Over Production Allowance Percentage,Peste producție Reduceri Procentaj
+DocType: Employee Loan,Repayment Schedule,rambursare Program
 DocType: Shipping Rule Condition,Shipping Rule Condition,Regula Condiții presetate
 DocType: Holiday List,Get Weekly Off Dates,Obtine Perioada Libera Saptamanala
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,Data de Incheiere nu poate fi anterioara Datei de Incepere
 DocType: Sales Person,Select company name first.,Selectați numele companiei în primul rând.
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +154,Dr,Dr
 apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Cotatiilor primite de la furnizori.
-apps/erpnext/erpnext/controllers/selling_controller.py +23,To {0} | {1} {2},Pentru a {0} | {1} {2}
+apps/erpnext/erpnext/controllers/selling_controller.py +24,To {0} | {1} {2},Pentru a {0} | {1} {2}
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Vârstă medie
 DocType: Opportunity,Your sales person who will contact the customer in future,Persoana de vânzări care va contacta clientul în viitor
 apps/erpnext/erpnext/public/js/setup_wizard.js +266,List a few of your suppliers. They could be organizations or individuals.,Listeaza cativa din furnizorii dvs. Ei ar putea fi organizații sau persoane fizice.
 apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Vezi toate produsele
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +59,All BOMs,toate BOM
 DocType: Company,Default Currency,Monedă implicită
 DocType: Expense Claim,From Employee,Din Angajat
 apps/erpnext/erpnext/controllers/accounts_controller.py +413,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Atenție: Sistemul nu va verifica supraîncărcată din sumă pentru postul {0} din {1} este zero
@@ -1062,7 +1132,7 @@
 DocType: Upload Attendance,Attendance From Date,Prezenţa del la data
 DocType: Appraisal Template Goal,Key Performance Area,Domeniu de Performanță Cheie
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +54,Transportation,Transport
-apps/erpnext/erpnext/controllers/item_variant.py +69,Invalid Attribute,Atribut nevalid
+apps/erpnext/erpnext/controllers/item_variant.py +94,Invalid Attribute,Atribut nevalid
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +201,{0} {1} must be submitted,{0} {1} trebuie să fie introdus
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +146,Quantity must be less than or equal to {0},Cantitatea trebuie sa fie mai mic sau egal cu {0}
 DocType: SMS Center,Total Characters,Total de caractere
@@ -1073,18 +1143,18 @@
 DocType: Company,Company registration numbers for your reference. Tax numbers etc.,Numerele de înregistrare companie pentru referință. Numerele fiscale etc
 DocType: Sales Partner,Distributor,Distribuitor
 DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Cosul de cumparaturi Articolul Transport
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +211,Production Order {0} must be cancelled before cancelling this Sales Order,Producția de Ordine {0} trebuie anulată înainte de a anula această comandă de vânzări
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +224,Production Order {0} must be cancelled before cancelling this Sales Order,Producția de Ordine {0} trebuie anulată înainte de a anula această comandă de vânzări
 apps/erpnext/erpnext/public/js/controllers/transaction.js +52,Please set 'Apply Additional Discount On',Vă rugăm să setați &quot;Aplicați discount suplimentar pe&quot;
 ,Ordered Items To Be Billed,Comandat de Articole Pentru a fi facturat
 apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,Din Gama trebuie să fie mai mică de la gama
 DocType: Global Defaults,Global Defaults,Valori Implicite Globale
-apps/erpnext/erpnext/projects/doctype/project/project.py +195,Project Collaboration Invitation,Colaborare proiect Invitație
+apps/erpnext/erpnext/projects/doctype/project/project.py +202,Project Collaboration Invitation,Colaborare proiect Invitație
 DocType: Salary Slip,Deductions,Deduceri
 DocType: Leave Allocation,LAL/,LAL /
 apps/erpnext/erpnext/public/js/financial_statements.js +74,Start Year,Anul de începere
 DocType: Purchase Invoice,Start date of current invoice's period,Data perioadei de factura de curent începem
 DocType: Salary Slip,Leave Without Pay,Concediu Fără Plată
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +328,Capacity Planning Error,Capacitate de eroare de planificare
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +346,Capacity Planning Error,Capacitate de eroare de planificare
 ,Trial Balance for Party,Trial Balance pentru Party
 DocType: Lead,Consultant,Consultant
 DocType: Salary Slip,Earnings,Câștiguri
@@ -1099,19 +1169,23 @@
 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""","Acest lucru va fi adăugat la Codul punctul de varianta. De exemplu, în cazul în care abrevierea este ""SM"", iar codul produs face ""T-SHIRT"", codul punctul de varianta va fi ""T-SHIRT-SM"""
 DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Pay net (în cuvinte) vor fi vizibile după ce salvați fluturasul de salariu.
 DocType: Purchase Invoice,Is Return,Este de returnare
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +768,Return / Debit Note,Returnare / debit Notă
 DocType: Price List Country,Price List Country,Lista de preturi Țară
 DocType: Item,UOMs,UOMs
 apps/erpnext/erpnext/stock/utils.py +182,{0} valid serial nos for Item {1},{0} numere de serie valabile pentru articolul {1}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Cod articol nu pot fi schimbate pentru Serial No.
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +24,POS Profile {0} already created for user: {1} and company {2},POS Profile {0} deja creat pentru utilizator: {1} și compania {2}
-DocType: Purchase Order Item,UOM Conversion Factor,Factorul de conversie UOM
+DocType: Sales Invoice Item,UOM Conversion Factor,Factorul de conversie UOM
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +24,Please enter Item Code to get Batch Number,Vă rugăm să introduceți codul de articol pentru a obține numărul de lot
 DocType: Stock Settings,Default Item Group,Group Articol Implicit
+DocType: Employee Loan,Partially Disbursed,parţial Se eliberează
 DocType: Grading Structure,Grading System Name,Nume sistem de clasificare a
 apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Baza de date furnizor.
 DocType: Account,Balance Sheet,Bilant
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +708,Cost Center For Item with Item Code ',Centrul de cost pentru postul cu codul Postul '
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1908,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Modul de plată nu este configurat. Vă rugăm să verificați, dacă contul a fost setat pe modul de plăți sau la POS Profil."
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2304,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.","Modul de plată nu este configurat. Vă rugăm să verificați, dacă contul a fost setat pe modul de plăți sau la POS Profil."
 DocType: Opportunity,Your sales person will get a reminder on this date to contact the customer,Persoană de vânzări va primi un memento la această dată pentru a lua legătura cu clientul
+apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +75,Same item cannot be entered multiple times.,Același articol nu poate fi introdus de mai multe ori.
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Further accounts can be made under Groups, but entries can be made against non-Groups","Conturile suplimentare pot fi făcute sub Groups, dar intrările pot fi făcute împotriva non-Grupuri"
 DocType: Lead,Lead,Conducere
 DocType: Email Digest,Payables,Datorii
@@ -1124,26 +1198,29 @@
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +57,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Stocul Ledger Înscrieri și GL intrările sunt postate pentru selectate Veniturile achiziție
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Postul 1
 DocType: Holiday,Holiday,Vacanță
+DocType: Support Settings,Close Issue After Days,Închide Problemă După Zile
 DocType: Leave Control Panel,Leave blank if considered for all branches,Lăsați necompletat dacă se consideră pentru toate ramurile
 apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},C-formă nu se aplică pentru factură: {0}
 DocType: Payment Reconciliation,Unreconciled Payment Details,Nereconciliate Detalii de plată
 DocType: Global Defaults,Current Fiscal Year,An Fiscal Curent
 DocType: Purchase Order,Group same items,Același grup de elemente
 DocType: Global Defaults,Disable Rounded Total,Dezactivati Totalul Rotunjit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +441,'Entries' cannot be empty,'Intrările' nu pot fi vide
-apps/erpnext/erpnext/utilities/transaction_base.py +78,Duplicate row {0} with same {1},Inregistrare {0} este duplicata cu aceeași {1}
+DocType: Employee Loan Application,Repayment Info,Info rambursarea
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +436,'Entries' cannot be empty,'Intrările' nu pot fi vide
+apps/erpnext/erpnext/utilities/transaction_base.py +77,Duplicate row {0} with same {1},Inregistrare {0} este duplicata cu aceeași {1}
 ,Trial Balance,Balanta
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +413,Fiscal Year {0} not found,Anul fiscal {0} nu a fost găsit
-apps/erpnext/erpnext/config/hr.py +299,Setting up Employees,Configurarea angajati
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +416,Fiscal Year {0} not found,Anul fiscal {0} nu a fost găsit
+apps/erpnext/erpnext/config/hr.py +296,Setting up Employees,Configurarea angajati
 DocType: Sales Order,SO-,ASA DE-
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +155,Please select prefix first,Vă rugăm să selectați prefix întâi
 DocType: Employee,O-,O-
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +151,Research,Cercetarea
 DocType: Maintenance Visit Purpose,Work Done,Activitatea desfășurată
-apps/erpnext/erpnext/controllers/item_variant.py +25,Please specify at least one attribute in the Attributes table,Vă rugăm să specificați cel puțin un atribut în tabelul Atribute
+apps/erpnext/erpnext/controllers/item_variant.py +33,Please specify at least one attribute in the Attributes table,Vă rugăm să specificați cel puțin un atribut în tabelul Atribute
 DocType: Announcement,All Students,toţi elevii
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +44,Item {0} must be a non-stock item,Postul {0} trebuie să fie un element de bază non-stoc
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +71,View Ledger,Vezi Ledger
+DocType: Grading Scale,Intervals,intervale
 apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Cel mai devreme
 apps/erpnext/erpnext/stock/doctype/item/item.py +509,"An Item Group exists with same name, please change the item name or rename the item group","Există un grup de articole cu aceeaşi denumire, vă rugăm să schimbați denumirea articolului sau să redenumiţi grupul articolului"
 apps/erpnext/erpnext/schools/report/absent_student_report/absent_student_report.py +46,Student Mobile No.,Elev mobil Nr
@@ -1153,7 +1230,6 @@
 DocType: Salary Slip,Gross Pay,Plata Bruta
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: Activity Type is mandatory.,Rândul {0}: Activitatea de tip este obligatorie.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +164,Dividends Paid,Dividendele plătite
-DocType: Task,depends_on_tasks,depends_on_tasks
 apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Registru Jurnal
 DocType: Stock Reconciliation,Difference Amount,Diferența Suma
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +170,Retained Earnings,Venituri Reținute
@@ -1167,11 +1243,14 @@
 DocType: Email Digest,New Income,noul venit
 DocType: Buying Settings,Maintain same rate throughout purchase cycle,Menține aceeași cată in cursul ciclului de cumpărare
 DocType: Opportunity Item,Opportunity Item,Oportunitate Articol
+,Student and Guardian Contact Details,Student și Guardian Detalii de contact
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,Row {0}: For supplier {0} Email Address is required to send email,Rândul {0}: furnizor {0} Adresa de e-mail este necesară pentru a trimite e-mail
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +70,Temporary Opening,Deschiderea temporară
 ,Employee Leave Balance,Bilant Concediu Angajat
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +148,Balance for Account {0} must always be {1},Bilanţă pentru contul {0} trebuie să fie întotdeauna {1}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},Rata de evaluare cerute pentru postul în rândul {0}
 apps/erpnext/erpnext/public/js/setup_wizard.js +328,Example: Masters in Computer Science,Exemplu: Master în Informatică
+DocType: Item,Item Manufacturers,producătorii Postul
 DocType: Purchase Invoice,Rejected Warehouse,Depozit Respins
 DocType: GL Entry,Against Voucher,Comparativ voucherului
 DocType: Item,Default Buying Cost Center,Centru de Cost Cumparare Implicit
@@ -1179,10 +1258,11 @@
 apps/erpnext/erpnext/accounts/page/pos/pos.js +73, to ,la
 DocType: Item,Lead Time in days,Timp de plumb în zile
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Rezumat conturi pentru plăți
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +329,Payment of salary from {0} to {1},Plata salariului de la {0} la {1}
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +332,Payment of salary from {0} to {1},Plata salariului de la {0} la {1}
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +214,Not authorized to edit frozen Account {0},Nu este autorizat pentru a edita contul congelate {0}
 DocType: Journal Entry,Get Outstanding Invoices,Obtine Facturi Neachitate
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +64,Sales Order {0} is not valid,Comandă de vânzări {0} nu este valid
+apps/erpnext/erpnext/utilities/activation.py +92,Purchase orders help you plan and follow up on your purchases,Comenzile de aprovizionare vă ajuta să planificați și să urmați pe achizițiile dvs.
 apps/erpnext/erpnext/setup/doctype/company/company.py +209,"Sorry, companies cannot be merged","Ne pare rău, companiile nu se pot uni"
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +159,Small,Mic
 DocType: Employee,Employee Number,Numar angajat
@@ -1202,7 +1282,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +90,Indirect Expenses,Cheltuieli indirecte
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +77,Row {0}: Qty is mandatory,Rând {0}: Cant este obligatorie
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +8,Agriculture,Agricultură
-apps/erpnext/erpnext/accounts/page/pos/pos.js +711,Sync Master Data,Sincronizare Date
+apps/erpnext/erpnext/accounts/page/pos/pos.js +714,Sync Master Data,Sincronizare Date
 apps/erpnext/erpnext/public/js/setup_wizard.js +288,Your Products or Services,Produsele sau serviciile dvs.
 DocType: Mode of Payment,Mode of Payment,Mod de plata
 apps/erpnext/erpnext/stock/doctype/item/item.py +179,Website Image should be a public file or website URL,Site-ul Image ar trebui să fie un fișier public sau site-ul URL-ul
@@ -1214,11 +1294,12 @@
 DocType: Warehouse,Warehouse Contact Info,Date de contact depozit
 DocType: Payment Entry,Write Off Difference Amount,Diferență Sumă Piertdute
 DocType: Purchase Invoice,Recurring Type,Tip recurent
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +370,"{0}: Employee email not found, hence email not sent","{0}: e-mail angajat nu a fost găsit, prin urmare, nu poșta electronică trimisă"
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +390,"{0}: Employee email not found, hence email not sent","{0}: e-mail angajat nu a fost găsit, prin urmare, nu a fost trimis mail"
+DocType: Item,Foreign Trade Details,Detalii Comerț Exterior
 DocType: Email Digest,Annual Income,Venit anual
 DocType: Serial No,Serial No Details,Serial Nu Detalii
 DocType: Purchase Invoice Item,Item Tax Rate,Rata de Impozitare Articol
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,"For {0}, only credit accounts can be linked against another debit entry","Pentru {0}, numai conturi de credit poate fi legat de o altă intrare în debit"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +133,"For {0}, only credit accounts can be linked against another debit entry","Pentru {0}, numai conturi de credit poate fi legat de o altă intrare în debit"
 apps/erpnext/erpnext/projects/doctype/project/project.py +70,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Totală a tuturor greutăților sarcinii trebuie să fie 1. Ajustați greutățile tuturor sarcinilor de proiect în consecință
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +533,Delivery Note {0} is not submitted,Nota de Livrare {0} nu este introdusa
 apps/erpnext/erpnext/stock/get_item_details.py +132,Item {0} must be a Sub-contracted Item,Articolul {0} trebuie să fie un Articol Sub-contractat
@@ -1226,12 +1307,13 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +31,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Regula de stabilire a prețurilor este selectat în primul rând bazat pe ""Aplicați pe"" teren, care poate fi produs, Grupa de articole sau de brand."
 DocType: Hub Settings,Seller Website,Vânzător Site-ul
 DocType: Item,ITEM-,ARTICOL-
-apps/erpnext/erpnext/controllers/selling_controller.py +150,Total allocated percentage for sales team should be 100,Procentul total alocat pentru echipa de vânzări ar trebui să fie de 100
+apps/erpnext/erpnext/controllers/selling_controller.py +152,Total allocated percentage for sales team should be 100,Procentul total alocat pentru echipa de vânzări ar trebui să fie de 100
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +112,Production Order status is {0},Statutul de producție Ordinul este {0}
 DocType: Appraisal Goal,Goal,Obiectiv
 apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student batch Strength,Elev Putere lot
 DocType: Sales Invoice Item,Edit Description,Edit Descriere
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +725,For Supplier,Pentru furnizor
+,Team Updates,echipa Actualizări
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +778,For Supplier,Pentru furnizor
 DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Setarea Tipul de cont ajută în selectarea acest cont în tranzacții.
 DocType: Purchase Invoice,Grand Total (Company Currency),Total general (Valuta Companie)
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Creați Format imprimare
@@ -1245,7 +1327,7 @@
 DocType: Purchase Invoice,Total (Company Currency),Total (Company valutar)
 apps/erpnext/erpnext/stock/utils.py +177,Serial number {0} entered more than once,Număr de serie {0} a intrat de mai multe ori
 DocType: Depreciation Schedule,Journal Entry,Intrare în jurnal
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +71,{0} items in progress,{0} elemente în curs
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +77,{0} items in progress,{0} elemente în curs
 DocType: Workstation,Workstation Name,Stație de lucru Nume
 DocType: Grade Interval,Grade Code,Cod grad
 DocType: POS Item Group,POS Item Group,POS Articol Grupa
@@ -1265,7 +1347,7 @@
 apps/erpnext/erpnext/accounts/party.py +168,Please select a Company,Vă rugăm să selectați o companie
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +54,Privilege Leave,Privilege concediu
 DocType: Purchase Invoice,Supplier Invoice Date,Furnizor Data facturii
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +87,You need to enable Shopping Cart,Trebuie să activați Cosul de cumparaturi
+apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Trebuie să activați Cosul de cumparaturi
 DocType: Payment Entry,Writeoff,Achita
 DocType: Appraisal Template Goal,Appraisal Template Goal,Obiectiv model expertivă
 DocType: Salary Component,Earning,Câștig Salarial
@@ -1275,20 +1357,23 @@
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +81,Overlapping conditions found between:,Condiții se suprapun găsite între:
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +188,Against Journal Entry {0} is already adjusted against some other voucher,Comparativ intrării {0} în jurnal este deja ajustată comparativ altui voucher
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Valoarea totală Comanda
-apps/erpnext/erpnext/demo/setup/setup_data.py +314,Food,Produse Alimentare
+apps/erpnext/erpnext/demo/setup/setup_data.py +315,Food,Produse Alimentare
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Clasă de uzură 3
 DocType: Maintenance Schedule Item,No of Visits,Nu de vizite
 apps/erpnext/erpnext/schools/doctype/student_attendance_tool/student_attendance_tool.js +102,Mark Attendence,marcă de prezență
+apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +32,Enrolling student,student inregistrat
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},Valuta contului de închidere trebuie să fie {0}
 apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Suma de puncte pentru toate obiectivele ar trebui să fie 100. este {0}
 DocType: Project,Start and End Dates,Începere și de încheiere Date
 ,Delivered Items To Be Billed,Produse Livrate Pentru a fi Facturate
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Deschideți BOM {0}
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,Depozit nu poate fi schimbat pentru Serial No.
 DocType: Authorization Rule,Average Discount,Discount mediiu
 DocType: Purchase Invoice Item,UOM,UOM
 DocType: Rename Tool,Utilities,Utilitați
 DocType: Purchase Invoice Item,Accounting,Contabilitate
 DocType: Employee,EMP/,EMP /
+apps/erpnext/erpnext/hr/doctype/salary_component/salary_component.py +24,Abbreviation {0} already used for another salary component,Abreviere {0} deja utilizat pentru o altă componentă salarială
 DocType: Asset,Depreciation Schedules,Orarele de amortizare
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +89,Application period cannot be outside leave allocation period,Perioada de aplicare nu poate fi perioadă de alocare concediu în afara
 DocType: Activity Cost,Projects,Proiecte
@@ -1313,13 +1398,14 @@
 DocType: Employee,Prefered Email,E-mail Preferam
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +33,Net Change in Fixed Asset,Schimbarea net în active fixe
 DocType: Leave Control Panel,Leave blank if considered for all designations,Lăsați necompletat dacă se consideră pentru toate denumirile
+apps/erpnext/erpnext/accounts/doctype/account/account.py +176,Warehouse is mandatory for non group Accounts of type Stock,Depozit este obligatorie pentru conturile care nu sunt de grup de tip stoc
 apps/erpnext/erpnext/controllers/accounts_controller.py +669,Charge of type 'Actual' in row {0} cannot be included in Item Rate,"Taxa de tip 'Efectiv' în inregistrarea {0} nu poate fi inclus în Rata Articol"""
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +243,Max: {0},Max: {0}
 apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,De la Datetime
 DocType: Email Digest,For Company,Pentru Companie
 apps/erpnext/erpnext/config/support.py +17,Communication log.,Log comunicare.
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +154,"Request for Quotation is disabled to access from portal, for more check portal settings.","Cerere de ofertă este dezactivată accesul la portal, pentru mai multe setările portalului de verificare."
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Suma de Cumpărare
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Buying Amount,Suma de Cumpărare
 DocType: Sales Invoice,Shipping Address Name,Transport Adresa Nume
 apps/erpnext/erpnext/accounts/doctype/account/account.js +49,Chart of Accounts,Grafic Conturi
 DocType: Material Request,Terms and Conditions Content,Termeni și condiții de conținut
@@ -1340,6 +1426,7 @@
 DocType: HR Settings,Employee Settings,Setări Angajat
 ,Batch-Wise Balance History,Istoricul balanţei principale aferente lotului
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Setările de imprimare actualizate în format de imprimare respectiv
+DocType: Package Code,Package Code,Cod pachet
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +67,Apprentice,Începător
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +103,Negative Quantity is not allowed,Nu este permisă cantitate negativă
 DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
@@ -1359,6 +1446,7 @@
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Afișați soldurile L P &amp; anul fiscal unclosed lui
 DocType: Shipping Rule,Shipping Account,Contul de transport maritim
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +93,{0} {1}: Account {2} is inactive,{0} {1}: Cont {2} este inactiv
+apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Orders to help you plan your work and deliver on-time,Asigurați-vă Comenzi de vânzări pentru a vă ajuta să planificați munca și să livreze la timp
 DocType: Quality Inspection,Readings,Lecturi
 DocType: Stock Entry,Total Additional Costs,Costuri totale suplimentare
 DocType: Course Schedule,SH,SH
@@ -1369,7 +1457,7 @@
 DocType: Shipping Rule Condition,To Value,La valoarea
 DocType: Asset Movement,Stock Manager,Stock Manager
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +135,Source warehouse is mandatory for row {0},Depozit sursă este obligatorie pentru rând {0}
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +748,Packing Slip,Slip de ambalare
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +814,Packing Slip,Slip de ambalare
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +108,Office Rent,Birou inchiriat
 apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Setări de configurare SMS gateway-ul
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +60,Import Failed!,Import a eșuat!
@@ -1382,13 +1470,16 @@
 DocType: Opportunity,With Items,Cu articole
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,In Qty,În Cantitate
 DocType: Notification Control,Expense Claim Rejected,Revendicare Cheltuieli Respinsa
-DocType: Item Attribute,Item Attribute,Postul Atribut
+DocType: Item,Item Attribute,Postul Atribut
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +109,Government,Guvern
+apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Cheltuiala Revendicarea {0} există deja pentru vehicul Log
 apps/erpnext/erpnext/public/js/setup_wizard.js +41,Institute Name,Numele Institutului
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Vă rugăm să introduceți Suma de rambursare
 apps/erpnext/erpnext/config/stock.py +300,Item Variants,Variante Postul
 DocType: Company,Services,Servicii
 DocType: HR Settings,Email Salary Slip to Employee,E-mail Salariu Slip angajatului
 DocType: Cost Center,Parent Cost Center,Părinte Cost Center
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +868,Select Possible Supplier,Selectați Posibil furnizor
 DocType: Sales Invoice,Source,Sursă
 apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Afișează închis
 DocType: Leave Type,Is Leave Without Pay,Este concediu fără plată
@@ -1400,27 +1491,32 @@
 DocType: POS Profile,Apply Discount,Aplicați o reducere
 DocType: Employee External Work History,Total Experience,Experiența totală
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Proiecte deschise
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +265,Packing Slip(s) cancelled,Slip de ambalare (e) anulate
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +267,Packing Slip(s) cancelled,Slip de ambalare (e) anulate
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +31,Cash Flow from Investing,Cash Flow de la Investiții
 DocType: Program Course,Program Course,Curs Program
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +97,Freight and Forwarding Charges,Incarcatura și Taxe de Expediere
 DocType: Homepage,Company Tagline for website homepage,Firma Tagline pentru pagina de start site
 DocType: Item Group,Item Group Name,Denumire Grup Articol
 apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Luate
+DocType: Student,Date of Leaving,Data Părăsirea
 DocType: Pricing Rule,For Price List,Pentru Lista de Preturi
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +27,Executive Search,Cautare Executiva
+apps/erpnext/erpnext/utilities/activation.py +64,Create Leads,Creați Oportunitati
 DocType: Maintenance Schedule,Schedules,Orarele
 DocType: Purchase Invoice Item,Net Amount,Cantitate netă
 DocType: Purchase Order Item Supplied,BOM Detail No,Detaliu BOM nr.
+DocType: Landed Cost Voucher,Additional Charges,Costuri suplimentare
 DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Discount suplimentar Suma (companie de valuta)
 apps/erpnext/erpnext/accounts/doctype/account/account.js +7,Please create new account from Chart of Accounts.,Vă rugăm să creați un cont nou de Planul de conturi.
 DocType: Maintenance Visit,Maintenance Visit,Vizita Mentenanta
+DocType: Student,Leaving Certificate Number,Părăsirea Număr certificat
 DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Cantitate lot disponibilă în depozit
 apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Actualizare Format Print
 DocType: Landed Cost Voucher,Landed Cost Help,Costul Ajutor Landed
 DocType: Purchase Invoice,Select Shipping Address,Selectați adresa de expediere
 DocType: Leave Block List,Block Holidays on important days.,Blocaţi zile de sărbătoare în zilele importante.
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +59,Accounts Receivable Summary,Rezumat conturi de încasare
+DocType: Employee Loan,Monthly Repayment Amount,Suma de rambursare lunar
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +191,Please set User ID field in an Employee record to set Employee Role,Vă rugăm să setați câmp ID de utilizator într-o înregistrare angajat să stabilească Angajat rol
 DocType: UOM,UOM Name,Numele UOM
 apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +43,Contribution Amount,Contribuția Suma
@@ -1433,13 +1529,16 @@
 DocType: Program Enrollment Tool,Program Enrollments,Inscrierile pentru programul
 DocType: Sales Invoice Item,Brand Name,Denumire marcă
 DocType: Purchase Receipt,Transporter Details,Detalii Transporter
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2058,Default warehouse is required for selected item,depozitul implicit este necesar pentru elementul selectat
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2459,Default warehouse is required for selected item,depozitul implicit este necesar pentru elementul selectat
 apps/erpnext/erpnext/public/js/setup_wizard.js +303,Box,Cutie
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +865,Possible Supplier,posibil furnizor
 apps/erpnext/erpnext/public/js/setup_wizard.js +36,The Organization,Organizația
 DocType: Budget,Monthly Distribution,Distributie lunar
+apps/erpnext/erpnext/schools/doctype/student_group/student_group.py +48,Student Batch exists with same name,Lot Student există cu același nume
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,Receptor Lista goala. Vă rugăm să creați Receiver Lista
 DocType: Production Plan Sales Order,Production Plan Sales Order,Planul de producție comandă de vânzări
 DocType: Sales Partner,Sales Partner Target,Vânzări Partner țintă
+DocType: Loan Type,Maximum Loan Amount,Suma maximă a împrumutului
 DocType: Pricing Rule,Pricing Rule,Regula de stabilire a prețurilor
 DocType: Budget,Action if Annual Budget Exceeded,Acțiune în cazul în care anual Buget Depășit
 apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Cerere de material de cumpărare Ordine
@@ -1457,9 +1556,12 @@
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +40,No Items to pack,Nu sunt produse în ambalaj
 DocType: Shipping Rule Condition,From Value,Din Valoare
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +537,Manufacturing Quantity is mandatory,Cantitatea de fabricație este obligatorie
+DocType: Employee Loan,Repayment Method,Metoda de rambursare
 DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Dacă este bifată, pagina de pornire va fi implicit postul Grupului pentru site-ul web"
 DocType: Quality Inspection Reading,Reading 4,Reading 4
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +498,Default BOM for {0} not found for Project {1},BOM implicit pentru {0} nu a fost găsit pentru Project {1}
 apps/erpnext/erpnext/config/hr.py +127,Claims for company expense.,Cererile pentru cheltuieli companie.
+apps/erpnext/erpnext/utilities/activation.py +119,"Students are at the heart of the system, add all your students","Studenții sunt în centrul sistemului, adăugați toți elevii"
 apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Rând # {0}: Data de lichidare {1} nu poate fi înainte de Cheque Data {2}
 DocType: Company,Default Holiday List,Implicit Listă de vacanță
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +187,Row {0}: From Time and To Time of {1} is overlapping with {2},Rândul {0}: De la timp și Ora {1} se suprapune cu {2}
@@ -1470,19 +1572,22 @@
 DocType: Student Group,Set 0 for no limit,0 pentru a seta nici o limită
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +141,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,A doua zi (e) pe care se aplica pentru concediu sunt sărbători. Nu trebuie să se aplice pentru concediu.
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Retrimite e-mail de plată
-apps/erpnext/erpnext/utilities/activation.py +77,Make Quotation,Face ofertă
+apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Sarcina noua
+apps/erpnext/erpnext/utilities/activation.py +75,Make Quotation,Face ofertă
 apps/erpnext/erpnext/config/selling.py +216,Other Reports,alte rapoarte
 DocType: Dependent Task,Dependent Task,Sarcina dependent
 apps/erpnext/erpnext/stock/doctype/item/item.py +406,Conversion factor for default Unit of Measure must be 1 in row {0},Factor de Conversie pentru Unitatea de Măsură implicita trebuie să fie 1 pentru inregistrarea {0}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +208,Leave of type {0} cannot be longer than {1},Concediul de tip {0} nu poate dura mai mare de {1}
 DocType: Manufacturing Settings,Try planning operations for X days in advance.,Încercați planificarea operațiunilor de X zile în avans.
 DocType: HR Settings,Stop Birthday Reminders,De oprire de naștere Memento
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +255,Please set Default Payroll Payable Account in Company {0},Vă rugăm să setați Cont Cheltuieli suplimentare salarizare implicit în companie {0}
 DocType: SMS Center,Receiver List,Receptor Lista
-apps/erpnext/erpnext/accounts/page/pos/pos.js +942,Search Item,căutare articol
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1021,Search Item,căutare articol
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Consumat Suma
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +98,Net Change in Cash,Schimbarea net în numerar
+DocType: Assessment Plan,Grading Scale,Scala de notare
 apps/erpnext/erpnext/stock/doctype/item/item.py +401,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Unitate de măsură {0} a fost introdus mai mult de o dată în Factor de conversie Tabelul
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +567,Already completed,deja finalizat
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +599,Already completed,deja finalizat
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +23,Payment Request already exists {0},Cerere de plată există deja {0}
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Costul de articole emise
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +246,Quantity must not be more than {0},Cantitatea nu trebuie să fie mai mare de {0}
@@ -1494,12 +1599,12 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +194,Serial No {0} quantity {1} cannot be a fraction,Serial Nu {0} {1} cantitate nu poate fi o fracțiune
 apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Furnizor de tip maestru.
 DocType: Purchase Order Item,Supplier Part Number,Furnizor Număr
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +99,Conversion rate cannot be 0 or 1,Rata de conversie nu poate fi 0 sau 1
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +100,Conversion rate cannot be 0 or 1,Rata de conversie nu poate fi 0 sau 1
 DocType: Sales Invoice,Reference Document,Documentul de referință
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +185,{0} {1} is cancelled or stopped,{0} {1} este anulată sau oprită
 DocType: Accounts Settings,Credit Controller,Controler de Credit
 DocType: Delivery Note,Vehicle Dispatch Date,Dispeceratul vehicul Data
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,Purchase Receipt {0} is not submitted,Primirea de cumpărare {0} nu este prezentat
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +230,Purchase Receipt {0} is not submitted,Primirea de cumpărare {0} nu este prezentat
 DocType: Company,Default Payable Account,Implicit cont furnizori
 apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Setări pentru cosul de cumparaturi on-line, cum ar fi normele de transport maritim, lista de preturi, etc."
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +86,{0}% Billed,{0}% Facturat
@@ -1507,18 +1612,20 @@
 DocType: Party Account,Party Account,Party Account
 apps/erpnext/erpnext/config/setup.py +122,Human Resources,Resurse umane
 DocType: Lead,Upper Income,Venituri de sus
+DocType: Item Manufacturer,Item Manufacturer,Postul Producator
 apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +13,Reject,Respinge
 DocType: Journal Entry Account,Debit in Company Currency,Debit în companie valutar
 DocType: BOM Item,BOM Item,Articol BOM
 DocType: Appraisal,For Employee,Pentru Angajat
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +131,Row {0}: Advance against Supplier must be debit,Row {0}: Advance împotriva Furnizor trebuie să fie de debit
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +41,Make Disbursement Entry,Asigurați-debursare de intrare
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +126,Row {0}: Advance against Supplier must be debit,Row {0}: Advance împotriva Furnizor trebuie să fie de debit
 DocType: Company,Default Values,Valori implicite
 DocType: Expense Claim,Total Amount Reimbursed,Total suma rambursată
 apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Aceasta se bazează pe bușteni împotriva acestui vehicul. A se vedea calendarul de mai jos pentru detalii
 apps/erpnext/erpnext/schools/doctype/fees/fees.js +41,Collect,Colectarea
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +81,Against Supplier Invoice {0} dated {1},Comparativ facturii furnizorului {0} din data {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +82,Against Supplier Invoice {0} dated {1},Comparativ facturii furnizorului {0} din data {1}
 DocType: Customer,Default Price List,Lista de Prețuri Implicita
-apps/erpnext/erpnext/accounts/doctype/asset/asset.py +232,Asset Movement record {0} created,Mișcarea de înregistrare a activelor {0} creat
+apps/erpnext/erpnext/accounts/doctype/asset/asset.py +233,Asset Movement record {0} created,Mișcarea de înregistrare a activelor {0} creat
 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,Nu puteți șterge Anul fiscal {0}. Anul fiscal {0} este setat ca implicit în Setări globale
 DocType: Journal Entry,Entry Type,Tipul de intrare
 ,Customer Credit Balance,Balanța Clienți credit
@@ -1534,6 +1641,7 @@
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +64,None of the items have any change in quantity or value.,Nici unul din elementele au nici o schimbare în cantitate sau de valoare.
 apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +43,Warranty Claim,Garanție revendicarea
 ,Lead Details,Detalii Conducere
+DocType: Salary Slip,Loan repayment,Rambursare a creditului
 DocType: Vehicle Log,Service_Details,Service_Details
 DocType: Purchase Invoice,End date of current invoice's period,Data de încheiere a perioadei facturii curente
 DocType: Pricing Rule,Applicable For,Aplicabil pentru
@@ -1549,9 +1657,10 @@
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +59,'Total',&#39;Total&#39;
 DocType: Shopping Cart Settings,Enable Shopping Cart,Activați cosul de cumparaturi
 DocType: Employee,Permanent Address,Permanent Adresa
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +253,"Advance paid against {0} {1} cannot be greater \
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +248,"Advance paid against {0} {1} cannot be greater \
 						than Grand Total {2}",Avansul plătit împotriva {0} {1} nu poate fi mai mare \ decât Grand total {2}
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +148,Please select item code,Vă rugăm să selectați codul de articol
+DocType: Student Sibling,Studying in Same Institute,Studiind în același Institut
 DocType: Territory,Territory Manager,Teritoriu Director
 DocType: Packed Item,To Warehouse (Optional),Pentru a Depozit (opțional)
 DocType: Payment Entry,Paid Amount (Company Currency),Plătit Suma (Compania de valuta)
@@ -1572,7 +1681,7 @@
 apps/erpnext/erpnext/schools/doctype/course_schedule/course_schedule.py +26,Student Batch or Student Group is mandatory,Lot Student sau Grupul Student este obligatoriu
 DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Realizeaza Intrare de Contabilitate Pentru Fiecare Modificare a Stocului
 DocType: Leave Allocation,Total Leaves Allocated,Totalul Frunze alocate
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +155,Warehouse required at Row No {0},Depozit necesar la Row Nu {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +156,Warehouse required at Row No {0},Depozit necesar la Row Nu {0}
 apps/erpnext/erpnext/public/js/setup_wizard.js +78,Please enter valid Financial Year Start and End Dates,Va rugam sa introduceti valabil financiare Anul începe și a termina Perioada
 DocType: Employee,Date Of Retirement,Data Pensionare
 DocType: Upload Attendance,Get Template,Obține șablon
@@ -1598,7 +1707,7 @@
 ,Item-wise Sales Register,Registru Vanzari Articol-Avizat
 DocType: Asset,Gross Purchase Amount,Sumă brută Cumpărare
 DocType: Asset,Depreciation Method,Metoda de amortizare
-apps/erpnext/erpnext/accounts/page/pos/pos.js +684,Offline,Deconectat
+apps/erpnext/erpnext/accounts/page/pos/pos.js +686,Offline,Deconectat
 DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Este acest fiscală inclusă în rata de bază?
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Raport țintă
 DocType: Program Course,Required,Necesar
@@ -1608,7 +1717,9 @@
 DocType: Stock Reconciliation,Reconciliation JSON,Reconciliere JSON
 apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Prea multe coloane. Exporta raportul și imprima utilizând o aplicație de calcul tabelar.
 DocType: Purchase Invoice Item,Batch No,Lot nr.
+apps/erpnext/erpnext/setup/utils.py +106,Unable to find exchange rate for {0} to {1} for key date {2},Nu se poate găsi rata de schimb pentru {0} la {1} pentru data cheie {2}
 DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Permite mai multor comenzi de vânzări împotriva Ordinului de Procurare unui client
+apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Guardian2 Mobile No,Guardian2 mobil nr
 apps/erpnext/erpnext/setup/doctype/company/company.py +188,Main,Principal
 apps/erpnext/erpnext/stock/doctype/item/item.js +62,Variant,Variantă
 DocType: Naming Series,Set prefix for numbering series on your transactions,Set prefix pentru seria de numerotare pe tranzacțiile dvs.
@@ -1618,7 +1729,7 @@
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Oportunitatea de la câmp este obligatoriu
 DocType: Email Digest,Annual Expenses,Cheltuielile anuale
 DocType: Item,Variants,Variante
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +992,Make Purchase Order,Realizeaza Comanda de Cumparare
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +994,Make Purchase Order,Realizeaza Comanda de Cumparare
 DocType: SMS Center,Send To,Trimite la
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +152,There is not enough leave balance for Leave Type {0},Nu există echilibru concediu suficient pentru concediul de tip {0}
 DocType: Payment Reconciliation Payment,Allocated amount,Suma alocată
@@ -1635,15 +1746,19 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,Duplicate Serial No entered for Item {0},Nr. Serial introdus pentru articolul {0} este duplicat
 DocType: Shipping Rule Condition,A condition for a Shipping Rule,O condiție pentru o normă de transport
 DocType: Grading Structure,Grading Intervals,Intervale de notare
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +169,Please set filter based on Item or Warehouse,Vă rugăm să setați filtru bazat pe postul sau depozit
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +161,Please enter ,Te rog intra
+apps/erpnext/erpnext/controllers/accounts_controller.py +429,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Buying Settings","Nu se poate overbill pentru postul {0} în rândul {1} mai mult {2}. Pentru a permite supra-facturare, vă rugăm să setați în Setări de cumpărare"
+apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +188,Please set filter based on Item or Warehouse,Vă rugăm să setați filtru bazat pe postul sau depozit
 DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Greutatea netă a acestui pachet. (Calculat automat ca suma de greutate netă de produs)
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +82,Please create an Account for this Warehouse and link it. This cannot be done automatically as an account with name {0} already exists,Vă rugăm să creați un cont pentru acest depozit și conectați-l. Acest lucru nu se poate face în mod automat ca un cont cu numele {0} există deja
 DocType: Sales Order,To Deliver and Bill,Pentru a livra și Bill
 DocType: Student Batch,Instructors,instructorii
 DocType: GL Entry,Credit Amount in Account Currency,Suma de credit în cont valutar
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +510,BOM {0} must be submitted,BOM {0} trebuie să fie introdus
 DocType: Authorization Control,Authorization Control,Control de autorizare
 apps/erpnext/erpnext/controllers/buying_controller.py +304,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Row # {0}: Respins Warehouse este obligatorie împotriva postul respins {1}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +708,Payment,Plată
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +763,Payment,Plată
+apps/erpnext/erpnext/utilities/activation.py +82,Manage your orders,Gestionați comenzile
 DocType: Production Order Operation,Actual Time and Cost,Timp și cost efective
 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},Cerere de material de maximum {0} se poate face pentru postul {1} împotriva comandă de vânzări {2}
 DocType: Employee,Salutation,Salut
@@ -1651,7 +1766,8 @@
 DocType: Student Leave Application,Student Leave Application,Aplicație elev Concediul
 DocType: Item,Will also apply for variants,"Va aplică, de asemenea pentru variante"
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +149,"Asset cannot be cancelled, as it is already {0}","Activ nu poate fi anulat, deoarece este deja {0}"
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +40,Total working hours should not be greater than max working hours {0},Numărul total de ore de lucru nu trebuie sa fie mai mare de ore de lucru max {0}
+apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Angajat {0} pe jumătate de zi pe {1}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Numărul total de ore de lucru nu trebuie sa fie mai mare de ore de lucru max {0}
 apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Set de articole în momemntul vânzării.
 DocType: Quotation Item,Actual Qty,Cant efectivă
 DocType: Sales Invoice Item,References,Referințe
@@ -1661,6 +1777,7 @@
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Ați introdus elemente cu dubluri. Vă rugăm să rectifice și să încercați din nou.
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +91,Associate,Asociaţi
 DocType: Asset Movement,Asset Movement,Mișcarea activelor
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2031,New Cart,nou Coș
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,Articolul {0} nu este un articol serializat
 DocType: SMS Center,Create Receiver List,Creare Lista Recipienti
 DocType: Vehicle,Wheels,roţi
@@ -1718,6 +1835,7 @@
 ,Amount to Deliver,Sumă pentru livrare
 apps/erpnext/erpnext/public/js/setup_wizard.js +297,A Product or Service,Un Produs sau Serviciu
 apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,Start Termen Data nu poate fi mai devreme decât data Anul de începere a anului universitar la care este legat termenul (anului universitar {}). Vă rugăm să corectați datele și încercați din nou.
+DocType: Guardian,Guardian Interests,Guardian Interese
 DocType: Naming Series,Current Value,Valoare curenta
 apps/erpnext/erpnext/controllers/accounts_controller.py +248,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,ani fiscali multiple exista in data de {0}. Vă rugăm să setați companie în anul fiscal
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +233,{0} created,{0} creat
@@ -1735,7 +1853,7 @@
 apps/erpnext/erpnext/accounts/party.py +293,Due Date cannot be before Posting Date,Data Limita nu poate fi anterioara Datei de POstare
 DocType: Website Item Group,Website Item Group,Site-ul Grupa de articole
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +148,Duties and Taxes,Impozite și taxe
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +349,Please enter Reference date,Vă rugăm să introduceți data de referință
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +344,Please enter Reference date,Vă rugăm să introduceți data de referință
 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} înregistrări de plată nu pot fi filtrate de {1}
 DocType: Item Website Specification,Table for Item that will be shown in Web Site,Tabelul pentru postul care va fi afișat în site-ul
 DocType: Purchase Order Item Supplied,Supplied Qty,Furnizat Cantitate
@@ -1751,7 +1869,7 @@
 DocType: Payment Reconciliation Payment,Reference Row,rândul de referință
 DocType: Installation Note,Installation Time,Timp de instalare
 DocType: Sales Invoice,Accounting Details,Contabilitate Detalii
-apps/erpnext/erpnext/setup/doctype/company/company.js +66,Delete all the Transactions for this Company,Ștergeți toate tranzacțiile de acest companie
+apps/erpnext/erpnext/setup/doctype/company/company.js +67,Delete all the Transactions for this Company,Ștergeți toate tranzacțiile de acest companie
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +181,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Rând # {0}: {1} Funcționare nu este finalizată pentru {2} cantitate de produse finite în Producție Comanda # {3}. Vă rugăm să actualizați starea de funcționare prin timp Busteni
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +66,Investments,Investiții
 DocType: Issue,Resolution Details,Rezoluția Detalii
@@ -1760,6 +1878,8 @@
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +163,Please enter Material Requests in the above table,Vă rugăm să introduceți Cererile materiale din tabelul de mai sus
 DocType: Item Attribute,Attribute Name,Denumire atribut
 DocType: BOM,Show In Website,Arata pe site-ul
+DocType: Shopping Cart Settings,Show Quantity in Website,Arată Cantitatea în site-ul
+DocType: Employee Loan Application,Total Payable Amount,Suma totală de plată
 DocType: Task,Expected Time (in hours),Timp de așteptat (în ore)
 DocType: Item Reorder,Check in (group),Check-in (grup)
 ,Qty to Order,Cantitate pentru comandă
@@ -1768,9 +1888,11 @@
 DocType: Opportunity,Mins to First Response,Mins la First Response
 DocType: Pricing Rule,Margin Type,Tipul de marjă
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} ore
+DocType: Course,Default Grading Scale,Scale Standard Standard folosit
 DocType: Appraisal,For Employee Name,Pentru Numele Angajatului
 DocType: Holiday List,Clear Table,Sterge Masa
 DocType: C-Form Invoice Detail,Invoice No,Factura Nu
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +337,Make Payment,Plateste
 DocType: Room,Room Name,Numele camerei
 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}","Lasă nu poate fi aplicat / anulata pana la {0}, ca echilibru concediu a fost deja carry transmise în viitor înregistrarea alocare concediu {1}"
 DocType: Activity Cost,Costing Rate,Costing Rate
@@ -1784,8 +1906,10 @@
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Repetați Venituri Clienți
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +164,{0} ({1}) must have role 'Expense Approver',"{0} ({1}) trebuie să dețină rolul de ""aprobator cheltuieli"""
 apps/erpnext/erpnext/public/js/setup_wizard.js +303,Pair,Pereche
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +887,Select BOM and Qty for Production,Selectați BOM și Cant pentru producție
 DocType: Asset,Depreciation Schedule,Program de amortizare
 DocType: Bank Reconciliation Detail,Against Account,Comparativ contului
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,Half Day Date should be between From Date and To Date,Jumătate Data zi ar trebui să fie între De la data si pana in prezent
 DocType: Maintenance Schedule Detail,Actual Date,Data efectiva
 DocType: Item,Has Batch No,Are nr. de Lot
 apps/erpnext/erpnext/public/js/utils.js +90,Annual Billing: {0},Facturare anuală: {0}
@@ -1808,6 +1932,8 @@
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +144,Expected value after useful life must be greater than or equal to {0},Valoarea așteptată după viață utilă trebuie să fie mai mare sau egal cu {0}
 DocType: Purchase Receipt,Vehicle Number,Numărul de vehicule
 DocType: Purchase Invoice,The date on which recurring invoice will be stop,La data la care factura recurente vor fi opri
+DocType: Employee Loan,Loan Amount,Sumă împrumutată
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +396,Row {0}: Bill of Materials not found for the Item {1},Rândul {0}: Lista de materiale nu a fost găsit pentru elementul {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,Total frunze alocate {0} nu poate fi mai mic de frunze deja aprobate {1} pentru perioada
 DocType: Journal Entry,Accounts Receivable,Conturi de Incasare
 ,Supplier-Wise Sales Analytics,Furnizor înțelept Vânzări Analytics
@@ -1819,6 +1945,7 @@
 DocType: Landed Cost Voucher,Distribute Charges Based On,Împărțiți taxelor pe baza
 apps/erpnext/erpnext/templates/pages/projects.html +48,Timesheets,pontaje
 DocType: HR Settings,HR Settings,Setări Resurse Umane
+DocType: Salary Slip,net pay info,info net pay
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +117,Expense Claim is pending approval. Only the Expense Approver can update status.,Revendicarea Cheltuielilor este în curs de aprobare. Doar Aprobatorul de Cheltuieli poate actualiza statusul.
 DocType: Email Digest,New Expenses,Cheltuieli noi
 DocType: Purchase Invoice,Additional Discount Amount,Reducere suplimentară Suma
@@ -1827,6 +1954,7 @@
 apps/erpnext/erpnext/setup/doctype/company/company.py +273,Abbr can not be blank or space,Abbr nu poate fi gol sau spațiu
 apps/erpnext/erpnext/accounts/doctype/account/account.js +53,Group to Non-Group,Grup non-grup
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +50,Sports,Sport
+DocType: Loan Type,Loan Name,Nume de împrumut
 apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Raport real
 DocType: Student Siblings,Student Siblings,Siblings Student
 apps/erpnext/erpnext/public/js/setup_wizard.js +303,Unit,Unitate
@@ -1836,7 +1964,7 @@
 apps/erpnext/erpnext/public/js/setup_wizard.js +63,Your financial year ends on,Anul dvs. financiar se încheie pe
 DocType: POS Profile,Price List,Lista de prețuri
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} este acum anul fiscal implicit. Vă rugăm să reîmprospătați browser-ul dvs. pentru ca modificarea să aibă efect.
-apps/erpnext/erpnext/projects/doctype/task/task.js +26,Expense Claims,Creanțe cheltuieli
+apps/erpnext/erpnext/projects/doctype/task/task.js +37,Expense Claims,Creanțe cheltuieli
 DocType: Issue,Support,Suport
 ,BOM Search,BOM Căutare
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +188,Closing (Opening + Totals),Închiderea (deschidere + Totaluri)
@@ -1858,12 +1986,13 @@
 DocType: Territory,Classification of Customers by region,Clasificarea clienți în funcție de regiune
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +55,Difference Amount must be zero,Diferența Suma trebuie să fie zero
 DocType: Project,Gross Margin,Marja Brută
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +195,Please enter Production Item first,Va rugam sa introduceti de producție Articol întâi
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +188,Please enter Production Item first,Va rugam sa introduceti de producție Articol întâi
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Calculat Bank echilibru Declaratie
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,utilizator dezactivat
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +692,Quotation,Citat
+apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +743,Quotation,Citat
 DocType: Quotation,QTN-,QTN-
 DocType: Salary Slip,Total Deduction,Total de deducere
+,Production Analytics,Google Analytics de producție
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +172,Cost Updated,Cost actualizat
 DocType: Employee,Date of Birth,Data Nașterii
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +123,Item {0} has already been returned,Articolul {0} a fost deja returnat
@@ -1871,12 +2000,14 @@
 DocType: Opportunity,Customer / Lead Address,Client / Adresa principala
 apps/erpnext/erpnext/stock/doctype/item/item.py +209,Warning: Invalid SSL certificate on attachment {0},Atenție: certificat SSL invalid pe atașament {0}
 DocType: Student Admission,Eligibility,Eligibilitate
+apps/erpnext/erpnext/utilities/activation.py +65,"Leads help you get business, add all your contacts and more as your leads","Oportunitati de afaceri ajuta să obțineți, adăugați toate contactele și mai mult ca dvs. conduce"
 DocType: Production Order Operation,Actual Operation Time,Timp efectiv de funcționare
 DocType: Authorization Rule,Applicable To (User),Aplicabil pentru (utilizator)
 DocType: Purchase Taxes and Charges,Deduct,Deduce
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +188,Job Description,Descrierea postului
 DocType: Student Applicant,Applied,Aplicat
-DocType: Purchase Order Item,Qty as per Stock UOM,Cantitate conform Stock UOM
+DocType: Sales Invoice Item,Qty as per Stock UOM,Cantitate conform Stock UOM
+apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +52,Guardian2 Name,Nume Guardian2
 apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +130,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Caractere speciale in afara ""-"" ""."", ""#"", și ""/"" nu este permis în denumirea serie"
 DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Păstra Tractor de campanii de vanzari. Țineți evidența de afaceri, Cotațiile, comandă de vânzări, etc de la Campanii pentru a evalua Return on Investment."
 DocType: Expense Claim,Approver,Aprobator
@@ -1886,7 +2017,7 @@
 DocType: Request for Quotation,Manufacturing Manager,Manufacturing Manager de
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +192,Serial No {0} is under warranty upto {1},Serial Nu {0} este în garanție pana {1}
 apps/erpnext/erpnext/config/stock.py +158,Split Delivery Note into packages.,Împărțit de livrare Notă în pachete.
-apps/erpnext/erpnext/hooks.py +81,Shipments,Transporturile
+apps/erpnext/erpnext/hooks.py +87,Shipments,Transporturile
 DocType: Payment Entry,Total Allocated Amount (Company Currency),Suma totală alocată (Companie Moneda)
 DocType: Purchase Order Item,To be delivered to customer,Pentru a fi livrat clientului
 DocType: BOM,Scrap Material Cost,Cost resturi de materiale
@@ -1898,15 +2029,15 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +104,Miscellaneous Expenses,Cheltuieli diverse
 DocType: Global Defaults,Default Company,Companie Implicita
 apps/erpnext/erpnext/controllers/stock_controller.py +216,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,"Cheltuială sau Diferența cont este obligatorie pentru postul {0}, deoarece impactul valoare totală de stoc"
-apps/erpnext/erpnext/controllers/accounts_controller.py +429,"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings","Nu pot overbill pentru postul {0} în rândul {1} mai mult {2}. Pentru a permite supraîncărcată, vă rugăm să setați în stoc Setări"
 DocType: Payment Request,PR,relatii cu publicul
 DocType: Cheque Print Template,Bank Name,Denumire bancă
 apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +27,-Above,de mai sus
+DocType: Employee Loan,Employee Loan Account,Contul de împrumut Angajat
 DocType: Leave Application,Total Leave Days,Total de zile de concediu
 DocType: Email Digest,Note: Email will not be sent to disabled users,Notă: Adresa de email nu va fi trimis la utilizatorii cu handicap
 apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +41,Select Company...,Selectați compania ...
 DocType: Leave Control Panel,Leave blank if considered for all departments,Lăsați necompletat dacă se consideră pentru toate departamentele
-apps/erpnext/erpnext/config/hr.py +202,"Types of employment (permanent, contract, intern etc.).","Tipuri de locuri de muncă (permanent, contractul, intern etc)."
+apps/erpnext/erpnext/config/hr.py +219,"Types of employment (permanent, contract, intern etc.).","Tipuri de locuri de muncă (permanent, contractul, intern etc)."
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +380,{0} is mandatory for Item {1},{0} este obligatoriu pentru articolul {1}
 DocType: Process Payroll,Fortnightly,bilunară
 DocType: Currency Exchange,From Currency,Din moneda
@@ -1916,24 +2047,28 @@
 DocType: Purchase Invoice Item,Rate (Company Currency),Rata de (Compania de valuta)
 DocType: Student Guardian,Others,Altel
 DocType: Payment Entry,Unallocated Amount,Suma nealocată
-apps/erpnext/erpnext/templates/includes/product_page.js +65,Cannot find a matching Item. Please select some other value for {0}.,Nu pot găsi o potrivire articol. Vă rugăm să selectați o altă valoare pentru {0}.
+apps/erpnext/erpnext/templates/includes/product_page.js +69,Cannot find a matching Item. Please select some other value for {0}.,Nu pot găsi o potrivire articol. Vă rugăm să selectați o altă valoare pentru {0}.
 DocType: POS Profile,Taxes and Charges,Impozite și Taxe
 DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Un produs sau un serviciu care este cumpărat, vândut sau păstrat în stoc."
+apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Nu există mai multe actualizări
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +146,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Nu se poate selecta tipul de incasare ca 'Suma inregistrare precedenta' sau 'Total inregistrare precedenta' pentru prima inregistrare
 apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Postul copil nu ar trebui să fie un pachet de produse. Vă rugăm să eliminați elementul `{0}` și de a salva
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +12,Banking,Bancar
+apps/erpnext/erpnext/utilities/activation.py +109,Add Timesheets,Adăugați pontaje
 DocType: Vehicle Service,Service Item,Postul de servicii
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,"Vă rugăm să faceți clic pe ""Generate Program"", pentru a obține programul"
 apps/erpnext/erpnext/schools/doctype/course_scheduling_tool/course_scheduling_tool.py +55,There were errors while deleting following schedules:,Au existat erori în timpul ștergerii următoarele programe:
 DocType: Bin,Ordered Quantity,Ordonat Cantitate
 apps/erpnext/erpnext/public/js/setup_wizard.js +52,"e.g. ""Build tools for builders""","de exemplu ""Construi instrumente de constructori """
+DocType: Grading Scale,Grading Scale Intervals,Intervale de notare Scala
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +126,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}: Intrarea contabila {2} poate fi făcută numai în moneda: {3}
 DocType: Production Order,In Process,În procesul de
 DocType: Authorization Rule,Itemwise Discount,Reducere Articol-Avizat
 apps/erpnext/erpnext/config/accounts.py +69,Tree of financial accounts.,Arborescentă conturilor financiare.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +357,{0} against Sales Order {1},{0} comparativ cu comanda de vânzări {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +352,{0} against Sales Order {1},{0} comparativ cu comanda de vânzări {1}
 DocType: Account,Fixed Asset,Activ Fix
 apps/erpnext/erpnext/config/stock.py +315,Serialized Inventory,Inventarul serializat
+DocType: Employee Loan,Account Info,Informatii cont
 DocType: Activity Type,Default Billing Rate,Rata de facturare implicit
 DocType: Sales Invoice,Total Billing Amount,Suma totală de facturare
 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.,Trebuie să existe o valoare implicită de intrare cont de e-mail-ului pentru ca aceasta să funcționeze. Vă rugăm să configurați un implicit de intrare cont de e-mail (POP / IMAP) și încercați din nou.
@@ -1943,7 +2078,7 @@
 apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,Comanda de vânzări la plată
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +85,CEO,CEO
 DocType: Expense Claim Detail,Expense Claim Detail,Detaliu Revendicare Cheltuieli
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +847,Please select correct account,Vă rugăm să selectați contul corect
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +848,Please select correct account,Vă rugăm să selectați contul corect
 DocType: Item,Weight UOM,Greutate UOM
 DocType: Salary Structure Employee,Salary Structure Employee,Structura de salarizare Angajat
 DocType: Employee,Blood Group,Grupă de sânge
@@ -1962,9 +2097,11 @@
 DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Dacă ați creat un model standard la taxele de vânzare și taxe Format, selectați una și faceți clic pe butonul de mai jos."
 DocType: BOM Scrap Item,Basic Amount (Company Currency),Suma de bază (Companie Moneda)
 DocType: Student,Guardians,tutorii
+DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Prețurile nu vor fi afișate în cazul în care Prețul de listă nu este setat
 apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +29,Please specify a country for this Shipping Rule or check Worldwide Shipping,Vă rugăm să specificați o țară pentru această regulă Transport sau verificați Expediere
 DocType: Stock Entry,Total Incoming Value,Valoarea totală a sosi
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +324,Debit To is required,Pentru debit este necesar
+apps/erpnext/erpnext/utilities/activation.py +110,"Timesheets help keep track of time, cost and billing for activites done by your team","Pontaje ajuta să urmăriți timp, costuri și de facturare pentru activitati efectuate de echipa ta"
 apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Cumparare Lista de preturi
 DocType: Offer Letter Term,Offer Term,Termen oferta
 DocType: Quality Inspection,Quality Manager,Manager de calitate
@@ -1973,16 +2110,18 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +154,Please select Incharge Person's name,Vă rugăm să selectați numele Incharge Persoana
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +51,Technology,Tehnologia nou-aparuta
 apps/erpnext/erpnext/public/js/utils.js +92,Total Unpaid: {0},Neremunerat totală: {0}
+DocType: BOM Website Operation,BOM Website Operation,Site-ul BOM Funcționare
 apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Offer Letter,Oferta Scrisoare
 apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Genereaza Cereri de Material (MRP) și Comenzi de Producție.
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +65,Total Invoiced Amt,Totală facturată Amt
 DocType: BOM,Conversion Rate,Rata de conversie
+apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Cauta produse
 DocType: Timesheet Detail,To Time,La timp
 DocType: Authorization Rule,Approving Role (above authorized value),Aprobarea Rol (mai mare decât valoarea autorizată)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +109,Credit To account must be a Payable account,Credit Pentru cont trebuie să fie un cont de plati
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +110,Credit To account must be a Payable account,Credit Pentru cont trebuie să fie un cont de plati
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +272,BOM recursion: {0} cannot be parent or child of {2},Recursivitate FDM: {0} nu poate fi parinte sau copil lui {2}
 DocType: Production Order Operation,Completed Qty,Cantitate Finalizata
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +141,"For {0}, only debit accounts can be linked against another credit entry","Pentru {0}, numai conturi de debit poate fi legat de o altă intrare în credit"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,"For {0}, only debit accounts can be linked against another credit entry","Pentru {0}, numai conturi de debit poate fi legat de o altă intrare în credit"
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,Lista de prețuri {0} este dezactivat
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty cannot be more than {1} for operation {2},Rândul {0}: Completat Cant nu poate fi mai mare de {1} pentru funcționare {2}
 DocType: Manufacturing Settings,Allow Overtime,Permiteți ore suplimentare
@@ -1995,12 +2134,13 @@
 apps/erpnext/erpnext/public/js/templates/address_list.html +1,New Address,Adresa noua
 DocType: Quality Inspection,Sample Size,Eșantionul de dimensiune
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +44,Please enter Receipt Document,Vă rugăm să introduceți Document Primirea
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +375,All items have already been invoiced,Toate articolele au fost deja facturate
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +376,All items have already been invoiced,Toate articolele au fost deja facturate
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +47,Please specify a valid 'From Case No.',"Vă rugăm să specificați un valabil ""Din cauza nr"""
 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,"Centre de costuri pot fi realizate în grupuri, dar intrările pot fi făcute împotriva non-Grupuri"
 DocType: Project,External,Extern
 apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Utilizatori și permisiuni
 DocType: Vehicle Log,VLOG.,VLOG.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +920,Production Orders Created: {0},Comenzi de producție Creat: {0}
 DocType: Branch,Branch,Ramură
 DocType: Guardian,Mobile Number,Numar de mobil
 apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Imprimarea și Branding
@@ -2009,7 +2149,8 @@
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +188,Serial No {0} not found,Serial nr {0} nu a fost găsit
 apps/erpnext/erpnext/schools/report/student_batch_wise_attendance/student_batch_wise_attendance.py +41,Student Batch,Lot de student
 apps/erpnext/erpnext/public/js/setup_wizard.js +242,Your Customers,Clienții dvs.
-apps/erpnext/erpnext/projects/doctype/project/project.py +183,You have been invited to collaborate on the project: {0},Ați fost invitat să colaboreze la proiect: {0}
+apps/erpnext/erpnext/utilities/activation.py +120,Make Student,Asigurați-Student
+apps/erpnext/erpnext/projects/doctype/project/project.py +190,You have been invited to collaborate on the project: {0},Ați fost invitat să colaboreze la proiect: {0}
 DocType: Leave Block List Date,Block Date,Dată blocare
 apps/erpnext/erpnext/templates/generators/student_admission.html +23,Apply Now,Aplica acum
 DocType: Sales Order,Not Delivered,Nu Pronunțată
@@ -2022,7 +2163,7 @@
 DocType: Timesheet Detail,Costing Amount,Costing Suma
 DocType: Student Admission,Application Fee,Taxă de aplicare
 DocType: Process Payroll,Submit Salary Slip,Prezenta Salariul Slip
-apps/erpnext/erpnext/controllers/selling_controller.py +164,Maxiumm discount for Item {0} is {1}%,Reducere Maxiumm pentru postul {0} este {1}%
+apps/erpnext/erpnext/controllers/selling_controller.py +166,Maxiumm discount for Item {0} is {1}%,Reducere Maxiumm pentru postul {0} este {1}%
 apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Importare în masă
 DocType: Sales Partner,Address & Contacts,Adresă şi contacte
 DocType: SMS Log,Sender Name,Sender Name
@@ -2030,7 +2171,7 @@
 DocType: SMS Log,Sent To,Trimis La
 DocType: Payment Request,Make Sales Invoice,Realizeaza Factura de Vanzare
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +59,Softwares,Softwares
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +50,Next Contact Date cannot be in the past,În continuare Contact Data nu poate fi în trecut
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +49,Next Contact Date cannot be in the past,În continuare Contact Data nu poate fi în trecut
 DocType: Company,For Reference Only.,Numai Pentru referință.
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +52,Invalid {0}: {1},Invalid {0}: {1}
 DocType: Purchase Invoice,PINV-RET-,PINV-RET-
@@ -2044,12 +2185,13 @@
 apps/erpnext/erpnext/stock/get_item_details.py +112,No Item with Barcode {0},Nici un articol cu coduri de bare {0}
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,Cazul Nr. nu poate fi 0
 DocType: Item,Show a slideshow at the top of the page,Arata un slideshow din partea de sus a paginii
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +444,Boms,BOM
 apps/erpnext/erpnext/stock/doctype/item/item.py +135,Stores,Magazine
 DocType: Serial No,Delivery Time,Timp de Livrare
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Uzură bazată pe
 DocType: Item,End of Life,Sfârsitul vieții
-apps/erpnext/erpnext/demo/setup/setup_data.py +317,Travel,Călători
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +171,No active or default Salary Structure found for employee {0} for the given dates,Nr Structură activă sau Salariul implicit găsite pentru angajat al {0} pentru datele indicate
+apps/erpnext/erpnext/demo/setup/setup_data.py +318,Travel,Călători
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,No active or default Salary Structure found for employee {0} for the given dates,Nr Structură activă sau Salariul implicit găsite pentru angajat al {0} pentru datele indicate
 DocType: Leave Block List,Allow Users,Permiteți utilizatori
 DocType: Purchase Order,Customer Mobile No,Client Mobile Nu
 DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Urmăriți Venituri separat și cheltuieli verticale produse sau divizii.
@@ -2057,10 +2199,10 @@
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +25,Update Cost,Actualizare Cost
 DocType: Item Reorder,Item Reorder,Reordonare Articol
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +437,Show Salary Slip,Afișează Salariu alunecare
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +735,Transfer Material,Material de transfer
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +786,Transfer Material,Material de transfer
 DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Specifica operațiunilor, costurile de exploatare și să dea o operațiune unică nu pentru operațiunile dumneavoastră."
 apps/erpnext/erpnext/controllers/status_updater.py +189,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Acest document este peste limita de {0} {1} pentru elementul {4}. Faci un alt {3} împotriva aceleași {2}?
-apps/erpnext/erpnext/public/js/controllers/transaction.js +957,Please set recurring after saving,Vă rugăm să setați recurente după salvare
+apps/erpnext/erpnext/public/js/controllers/transaction.js +991,Please set recurring after saving,Vă rugăm să setați recurente după salvare
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +710,Select change amount account,cont Selectați suma schimbare
 DocType: Purchase Invoice,Price List Currency,Lista de pret Valuta
 DocType: Naming Series,User must always select,Utilizatorul trebuie să selecteze întotdeauna
@@ -2080,22 +2222,24 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Source of Funds (Liabilities),Sursa fondurilor (pasive)
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +372,Quantity in row {0} ({1}) must be same as manufactured quantity {2},"Cantitatea în rândul {0} ({1}), trebuie să fie aceeași ca și cantitatea produsă {2}"
 DocType: Appraisal,Employee,Angajat
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +237,{0} {1} is fully billed,{0} {1} este complet facturat
+apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +20,Please define grade for treshold 0%,Vă rugăm să definească gradul de treshold 0%
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +232,{0} {1} is fully billed,{0} {1} este complet facturat
 DocType: Training Event,End Time,End Time
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +61,Active Salary Structure {0} found for employee {1} for the given dates,Salariu Structura activă {0} găsite pentru angajat {1} pentru datele indicate
 DocType: Payment Entry,Payment Deductions or Loss,Deducerile de plată sau pierdere
 apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Clauzele contractuale standard pentru vânzări sau de cumpărare.
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +81,Group by Voucher,Grup in functie de Voucher
 apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,conducte de vânzări
 DocType: Student Batch Student,Student Batch Student,Student Student Lot
-apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +219,Please set default account in Salary Component {0},Vă rugăm să setați contul implicit în Salariu Component {0}
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +221,Please set default account in Salary Component {0},Vă rugăm să setați contul implicit în Salariu Component {0}
 apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Obligatoriu pe
 DocType: Rename Tool,File to Rename,Fișier de Redenumiți
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +204,Please select BOM for Item in Row {0},Vă rugăm să selectați BOM pentru postul în rândul {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +200,Purchse Order number required for Item {0},Număr de ordine Purchse necesar pentru postul {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +208,Purchse Order number required for Item {0},Număr de ordine Purchse necesar pentru postul {0}
 apps/erpnext/erpnext/controllers/buying_controller.py +266,Specified BOM {0} does not exist for Item {1},BOM specificată {0} nu există pentru postul {1}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +199,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Programul de Mentenanta {0} trebuie anulat înainte de a anula aceasta Comandă de Vânzări
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Programul de Mentenanta {0} trebuie anulat înainte de a anula aceasta Comandă de Vânzări
 DocType: Notification Control,Expense Claim Approved,Revendicare Cheltuieli Aprobata
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +303,Salary Slip of employee {0} already created for this period,Platā angajatului {0} deja creat pentru această perioadă
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +316,Salary Slip of employee {0} already created for this period,Platā angajatului {0} deja creat pentru această perioadă
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +117,Pharmaceutical,Farmaceutic
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Costul de produsele cumparate
 DocType: Selling Settings,Sales Order Required,Comandă de vânzări obligatorii
@@ -2111,14 +2255,14 @@
 DocType: Upload Attendance,Attendance To Date,Prezenţa până la data
 DocType: Warranty Claim,Raised By,Ridicate de
 DocType: Payment Gateway Account,Payment Account,Cont de plăți
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +791,Please specify Company to proceed,Vă rugăm să specificați companiei pentru a continua
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +846,Please specify Company to proceed,Vă rugăm să specificați companiei pentru a continua
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +22,Net Change in Accounts Receivable,Schimbarea net în conturile de creanțe
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +50,Compensatory Off,Fara Masuri Compensatorii
 DocType: Offer Letter,Accepted,Acceptat
 DocType: SG Creation Tool Course,Student Group Name,Numele grupului studențesc
-apps/erpnext/erpnext/setup/doctype/company/company.js +46,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.,Vă rugăm să asigurați-vă că într-adevăr să ștergeți toate tranzacțiile pentru această companie. Datele dvs. de bază vor rămâne așa cum este. Această acțiune nu poate fi anulată.
+apps/erpnext/erpnext/setup/doctype/company/company.js +47,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.,Vă rugăm să asigurați-vă că într-adevăr să ștergeți toate tranzacțiile pentru această companie. Datele dvs. de bază vor rămâne așa cum este. Această acțiune nu poate fi anulată.
 DocType: Room,Room Number,Numărul de cameră
-apps/erpnext/erpnext/utilities/transaction_base.py +93,Invalid reference {0} {1},Referință invalid {0} {1}
+apps/erpnext/erpnext/utilities/transaction_base.py +92,Invalid reference {0} {1},Referință invalid {0} {1}
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +163,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) nu poate fi mai mare decât cantitatea planificată ({2}) aferent comenzii de producție {3}
 DocType: Shipping Rule,Shipping Rule Label,Regula de transport maritim Label
 apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Forum utilizator
@@ -2126,10 +2270,11 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444,"Could not update stock, invoice contains drop shipping item.","Nu a putut fi actualizat stoc, factura conține drop de transport maritim."
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +459,Quick Journal Entry,Quick Jurnal de intrare
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +142,You can not change rate if BOM mentioned agianst any item,Nu puteți schimba rata dacă BOM menționat agianst orice element
+apps/erpnext/erpnext/schools/doctype/student_batch/student_batch.py +24,Student Group exists with same name,Grupul Student există cu același nume
 DocType: Employee,Previous Work Experience,Anterior Work Experience
 DocType: Stock Entry,For Quantity,Pentru Cantitate
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +209,Please enter Planned Qty for Item {0} at row {1},Va rugam sa introduceti planificate Cantitate pentru postul {0} la rândul {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +234,{0} {1} is not submitted,{0} {1} nu este introdus
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +229,{0} {1} is not submitted,{0} {1} nu este introdus
 apps/erpnext/erpnext/config/stock.py +27,Requests for items.,Cererile de elemente.
 DocType: Production Planning Tool,Separate production order will be created for each finished good item.,Pentru producerea separată va fi creat pentru fiecare articol bun finit.
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +121,{0} must be negative in return document,{0} trebuie să fie negativ în documentul de retur
@@ -2144,6 +2289,7 @@
 DocType: Student Admission,Naming Series (for Student Applicant),Seria de denumire (pentru Student Solicitant)
 DocType: Delivery Note,Transporter Name,Transporter Nume
 DocType: Authorization Rule,Authorized Value,Valoarea autorizată
+DocType: BOM,Show Operations,Afișați Operații
 ,Minutes to First Response for Opportunity,Minute la First Response pentru oportunitate
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +58,Total Absent,Raport Absent
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +768,Item or Warehouse for row {0} does not match Material Request,Articolul sau Depozitul aferent inregistrariii {0} nu se potrivește cu Cererea de Material
@@ -2155,7 +2301,7 @@
 DocType: Operation,Default Workstation,Implicit Workstation
 DocType: Notification Control,Expense Claim Approved Message,Mesaj Aprobare Revendicare Cheltuieli
 DocType: Payment Entry,Deductions or Loss,Deducerile sau Pierdere
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +240,{0} {1} is closed,{0} {1} este închis
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +235,{0} {1} is closed,{0} {1} este închis
 DocType: Email Digest,How frequently?,Cât de frecvent?
 DocType: Purchase Receipt,Get Current Stock,Obține stocul curent
 apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Arborele de Bill de materiale
@@ -2177,15 +2323,16 @@
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,Aprobarea unui utilizator nu poate fi aceeași cu utilizatorul. Regula este aplicabilă pentru
 DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Rata de bază (conform Stock UOM)
 DocType: SMS Log,No of Requested SMS,Nu de SMS solicitat
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +227,Leave Without Pay does not match with approved Leave Application records,Concediu fără plată nu se potrivește cu înregistrările privind concediul de aplicare aprobat
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,Leave Without Pay does not match with approved Leave Application records,Concediu fără plată nu se potrivește cu înregistrările privind concediul de aplicare aprobat
 DocType: Campaign,Campaign-.####,Campanie-.####
 apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Pasii urmatori
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +697,Please supply the specified items at the best possible rates,Vă rugăm să furnizeze elementele specificate la cele mai bune tarife posibile
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +749,Please supply the specified items at the best possible rates,Vă rugăm să furnizeze elementele specificate la cele mai bune tarife posibile
+DocType: Selling Settings,Auto close Opportunity after 15 days,Auto închidere oportunitate după 15 zile
 apps/erpnext/erpnext/public/js/financial_statements.js +82,End Year,Anul de încheiere
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +119,Contract End Date must be greater than Date of Joining,Data de Incheiere Contract trebuie să fie ulterioara Datei Aderării
 DocType: Delivery Note,DN-,DN-
 DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Un distribuitor terță parte / dealer / agent comision / afiliat / reseller care vinde produsele companiilor pentru un comision.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +369,{0} against Purchase Order {1},{0} comparativ cu comanda de cumpărare {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Purchase Order {1},{0} comparativ cu comanda de cumpărare {1}
 DocType: SMS Settings,"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Introduceți parametrii url statici aici (de exemplu, expeditor = ERPNext, numele de utilizator = ERPNext, parola = 1234, etc)"
 DocType: Task,Actual Start Date (via Time Sheet),Real Data de începere (prin Ora Sheet)
 apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Acesta este un site web exemplu auto-generat de ERPNext
@@ -2236,8 +2383,9 @@
 apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +56,Fee Records Created - {0},Taxa de inregistrare Creat - {0}
 DocType: Asset Category Account,Asset Category Account,Cont activ Categorie
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +105,Cannot produce more Item {0} than Sales Order quantity {1},Nu se pot produce mai multe Articole {0} decât cantitatea din Ordinul de Vânzări {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +526,Stock Entry {0} is not submitted,Stock intrare {0} nu este prezentat
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +527,Stock Entry {0} is not submitted,Stock intrare {0} nu este prezentat
 DocType: Payment Reconciliation,Bank / Cash Account,Cont bancă / numerar
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Next Contact By cannot be same as the Lead Email Address,Următoarea Contact Prin faptul că nu poate fi aceeași cu adresa de e-mail Plumb
 DocType: Tax Rule,Billing City,Oraș de facturare
 DocType: Asset,Manual,Manual
 DocType: Salary Component Account,Salary Component Account,Contul de salariu Componentă
@@ -2266,7 +2414,7 @@
 DocType: Salary Structure,Total Earning,Câștigul salarial total de
 DocType: Purchase Receipt,Time at which materials were received,Timp în care s-au primit materiale
 DocType: Stock Ledger Entry,Outgoing Rate,Rata de ieșire
-apps/erpnext/erpnext/config/hr.py +207,Organization branch master.,Ramură organizație maestru.
+apps/erpnext/erpnext/config/hr.py +224,Organization branch master.,Ramură organizație maestru.
 apps/erpnext/erpnext/controllers/accounts_controller.py +286, or ,sau
 DocType: Sales Order,Billing Status,Stare facturare
 apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Raportați o problemă
@@ -2298,35 +2446,42 @@
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +52,Receipt document must be submitted,Document primire trebuie să fie depuse
 DocType: Purchase Invoice Item,Received Qty,Primit Cantitate
 DocType: Stock Entry Detail,Serial No / Batch,Serial No / lot
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +297,Not Paid and Not Delivered,Nu sunt plătite și nu sunt livrate
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +310,Not Paid and Not Delivered,Nu sunt plătite și nu sunt livrate
 DocType: Product Bundle,Parent Item,Părinte Articol
 DocType: Account,Account Type,Tipul Contului
 DocType: Delivery Note,DN-RET-,DN-RET-
+apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Nu există nicio foaie de timp
 apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,Lasă Tipul {0} nu poate fi transporta-transmise
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +216,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Programul de Mentenanta nu este generat pentru toate articolele. Vă rugăm să faceți clic pe 'Generare Program'
 ,To Produce,Pentru a produce
 apps/erpnext/erpnext/config/hr.py +93,Payroll,stat de plată
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pentru rândul {0} în {1}. Pentru a include {2} ratei punctul, randuri {3} De asemenea, trebuie să fie incluse"
+apps/erpnext/erpnext/utilities/activation.py +102,Make User,Asigurați-vă utilizatorului
 DocType: Packing Slip,Identification of the package for the delivery (for print),Identificarea pachetului pentru livrare (pentru imprimare)
 DocType: Bin,Reserved Quantity,Rezervat Cantitate
 DocType: Landed Cost Voucher,Purchase Receipt Items,Primirea de cumpărare Articole
 apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Formulare Personalizarea
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +36,Arrear,restanță
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +155,Depreciation Amount during the period,Suma de amortizare în timpul perioadei
 apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +38,Disabled template must not be default template,șablon cu handicap nu trebuie să fie șablon implicit
 DocType: Account,Income Account,Contul de venit
 DocType: Payment Request,Amount in customer's currency,Suma în moneda clientului
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +777,Delivery,Livrare
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +783,Delivery,Livrare
 DocType: Stock Reconciliation Item,Current Qty,Cantitate curentă
 DocType: BOM Item,"See ""Rate Of Materials Based On"" in Costing Section","A se vedea ""Rate de materiale bazate pe"" în Costing Secțiunea"
 DocType: Appraisal Goal,Key Responsibility Area,Domeni de Responsabilitate Cheie
+apps/erpnext/erpnext/utilities/activation.py +128,"Student Batches help you track attendance, assessments and fees for students","Student Sarjele ajută să urmăriți prezență, evaluările și taxele pentru studenți"
 DocType: Payment Entry,Total Allocated Amount,Suma totală alocată
 DocType: Item Reorder,Material Request Type,Material Cerere tip
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +273,Accural Journal Entry for salaries from {0} to {1},Accural Jurnal de intrare pentru salarii din {0} la {1}
+apps/erpnext/erpnext/accounts/page/pos/pos.js +768,"LocalStorage is full, did not save","LocalStorage este plin, nu a salvat"
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +79,Row {0}: UOM Conversion Factor is mandatory,Row {0}: Factorul de conversie UOM este obligatorie
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +17,Ref,Re
 DocType: Budget,Cost Center,Centrul de cost
 apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +36,Voucher #,Voucher #
 DocType: Notification Control,Purchase Order Message,Purchase Order Mesaj
 DocType: Tax Rule,Shipping Country,Transport Tara
+DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Ascunde Id-ul fiscal al Clientului din tranzacțiile de vânzare
 DocType: Upload Attendance,Upload HTML,Încărcați HTML
 DocType: Employee,Relieving Date,Alinarea Data
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +12,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Regula de stabilire a prețurilor se face pentru a suprascrie Pret / defini procent de reducere, pe baza unor criterii."
@@ -2346,6 +2501,7 @@
 DocType: Task,% Progress,% Progres
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +121,Gain/Loss on Asset Disposal,Câștigul / Pierdere de eliminare a activelor
 DocType: Training Event,Will send an email about the event to employees with status 'Open',Va trimite un e-mail despre eveniment angajaților cu statut &quot;Open&quot;
+DocType: Task,Depends on Tasks,Depinde de Sarcini
 apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Gestioneaza Ramificatiile de Group a Clientului.
 DocType: Supplier Quotation,SQTN-,SQTN-
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Numele noului centru de cost
@@ -2354,29 +2510,32 @@
 apps/erpnext/erpnext/templates/form_grid/stock_entry_grid.html +26,Not in Stock,Nu este în stoc
 DocType: Appraisal,HR User,Utilizator HR
 DocType: Purchase Invoice,Taxes and Charges Deducted,Impozite și Taxe dedus
-apps/erpnext/erpnext/hooks.py +110,Issues,Probleme
+apps/erpnext/erpnext/hooks.py +116,Issues,Probleme
 apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Statusul trebuie să fie unul din {0}
 DocType: Sales Invoice,Debit To,Debit Pentru
 DocType: Delivery Note,Required only for sample item.,Necesar numai pentru element de probă.
 DocType: Stock Ledger Entry,Actual Qty After Transaction,Cant efectivă după tranzacție
+apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +65,No salary slip found between {0} and {1},Nu slip salariu gasit între {0} și {1}
 ,Pending SO Items For Purchase Request,Până la SO articole pentru cerere de oferta
 apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +29,Student Admissions,Admitere Student
 apps/erpnext/erpnext/accounts/party.py +343,{0} {1} is disabled,{0} {1} este dezactivat
 DocType: Supplier,Billing Currency,Moneda de facturare
 DocType: Sales Invoice,SINV-RET-,SINV-RET-
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +162,Extra Large,Extra mare
+apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +58,Total Leaves,Frunze totale
 ,Profit and Loss Statement,Profit și pierdere
 DocType: Bank Reconciliation Detail,Cheque Number,Număr Cec
 ,Sales Browser,Browser de vanzare
 DocType: Journal Entry,Total Credit,Total credit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +529,Warning: Another {0} # {1} exists against stock entry {2},Atenție: Un alt {0} # {1} există împotriva intrării stoc {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +530,Warning: Another {0} # {1} exists against stock entry {2},Atenție: Un alt {0} # {1} există împotriva intrării stoc {2}
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +113,Local,Local
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Împrumuturi și Avansuri (Active)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Debitorii
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +161,Large,Mare
 DocType: Homepage Featured Product,Homepage Featured Product,Pagina de intrare de produse recomandate
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +198,All Assessment Groups,Toate grupurile de evaluare
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Nume nou depozit
-apps/erpnext/erpnext/accounts/report/financial_statements.py +219,Total {0} ({1}),Total {0} ({1})
+apps/erpnext/erpnext/accounts/report/financial_statements.py +218,Total {0} ({1}),Total {0} ({1})
 DocType: C-Form Invoice Detail,Territory,Teritoriu
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +152,Please mention no of visits required,Vă rugăm să menționați nici de vizite necesare
 DocType: Stock Settings,Default Valuation Method,Metoda de Evaluare Implicită
@@ -2388,14 +2547,15 @@
 DocType: Student Applicant,Application Status,Starea aplicației
 DocType: Fees,Fees,Taxele de
 DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Precizați Rata de schimb a converti o monedă în alta
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +145,Quotation {0} is cancelled,Citat {0} este anulat
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +149,Quotation {0} is cancelled,Citat {0} este anulat
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +26,Total Outstanding Amount,Total Suma Impresionant
 DocType: Sales Partner,Targets,Obiective
 DocType: Price List,Price List Master,Lista de preturi Masterat
 DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Toate tranzacțiile de vânzări pot fi etichetate comparativ mai multor **Persoane de vânzări** pentru ca dvs. sa puteţi configura și monitoriza obiective.
 ,S.O. No.,SO No.
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +158,Please create Customer from Lead {0},Vă rugăm să creați client de plumb {0}
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +163,Please create Customer from Lead {0},Vă rugăm să creați client de plumb {0}
 DocType: Price List,Applicable for Countries,Aplicabile pentru țările
+apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,Lăsați numai aplicațiile cu statut „Aprobat“ și „Respins“ pot fi depuse
 apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +38,Student Group Name is mandatory in row {0},Grupul studențesc Nume este obligatoriu în rândul {0}
 DocType: Homepage,Products to be shown on website homepage,Produsele care urmează să fie afișate pe pagina de pornire site
 apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,Acesta este un grup de clienți rădăcină și nu pot fi editate.
@@ -2404,7 +2564,7 @@
 DocType: Employee Education,Graduate,Absolvent
 DocType: Leave Block List,Block Days,Zile de blocare
 DocType: Journal Entry,Excise Entry,Intrare accize
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +66,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Atenție: comandă de vânzări {0} există deja împotriva Ordinului de Procurare clientului {1}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +69,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Atenție: comandă de vânzări {0} există deja împotriva Ordinului de Procurare clientului {1}
 DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
 
 Examples:
@@ -2431,16 +2591,20 @@
  1. Modalitati de litigii de adresare, indemnizație, răspunderea, etc. 
  1. Adresa și de contact ale companiei."
 DocType: Attendance,Leave Type,Tip Concediu
+DocType: Purchase Invoice,Supplier Invoice Details,Furnizor Detalii factură
 apps/erpnext/erpnext/controllers/stock_controller.py +222,Expense / Difference account ({0}) must be a 'Profit or Loss' account,"Cheltuială cont / Diferența ({0}) trebuie să fie un cont de ""profit sau pierdere"""
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +89,Name error: {0},Numele de eroare: {0}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +92,Name error: {0},Numele de eroare: {0}
 apps/erpnext/erpnext/stock/doctype/item/item_list.js +8,Shortage,Deficit
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +188,{0} {1} does not associated with {2} {3},{0} {1} nu asociat cu {2} {3}
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,Prezenţa pentru angajatul {0} este deja consemnată
 DocType: Packing Slip,If more than one package of the same type (for print),În cazul în care mai mult de un pachet de același tip (pentru imprimare)
+,Salary Register,Salariu Înregistrare
 DocType: Warehouse,Parent Warehouse,Depozit-mamă
 DocType: C-Form Invoice Detail,Net Total,Total net
+apps/erpnext/erpnext/config/hr.py +163,Define various loan types,Definirea diferitelor tipuri de împrumut
 DocType: Bin,FCFS Rate,Rata FCFS
 DocType: Payment Reconciliation Invoice,Outstanding Amount,Remarcabil Suma
+apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Timp (în min)
 DocType: Project Task,Working,De lucru
 DocType: Stock Ledger Entry,Stock Queue (FIFO),Stoc Queue (FIFO)
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +39,{0} does not belong to Company {1},{0} nu aparține companiei {1}
@@ -2448,17 +2612,19 @@
 DocType: Account,Round Off,Rotunji
 ,Requested Qty,A solicitat Cantitate
 DocType: Tax Rule,Use for Shopping Cart,Utilizați pentru Cos de cumparaturi
+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},Valoarea {0} pentru atributul {1} nu există în lista Item valabile Valorile atributelor pentru postul {2}
 DocType: BOM Item,Scrap %,Resturi%
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +45,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Taxele vor fi distribuite proporțional în funcție de produs Cantitate sau valoarea, ca pe dvs. de selecție"
 DocType: Maintenance Visit,Purposes,Scopuri
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +105,Atleast one item should be entered with negative quantity in return document,Cel puțin un element ar trebui să fie introduse cu cantitate negativa în documentul de returnare
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Operațiunea {0} mai mult decât orice ore de lucru disponibile în stație de lucru {1}, descompun operațiunea în mai multe operațiuni"
 ,Requested,Solicitată
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +84,No Remarks,Nu Observații
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,No Remarks,Nu Observații
 DocType: Purchase Invoice,Overdue,Întârziat
 DocType: Account,Stock Received But Not Billed,"Stock primite, dar nu Considerat"
 apps/erpnext/erpnext/accounts/doctype/account/account.py +88,Root Account must be a group,Contul de root trebuie să fie un grup
 DocType: Fees,FEE.,FEE.
+DocType: Employee Loan,Repaid/Closed,Nerambursate / Închis
 DocType: Item,Total Projected Qty,Cantitate totală prevăzută
 DocType: Monthly Distribution,Distribution Name,Denumire Distribuție
 DocType: Course,Course Code,Codul cursului
@@ -2475,12 +2641,13 @@
 DocType: Stock Entry,Material Transfer for Manufacture,Transfer de materii pentru fabricarea
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +18,Discount Percentage can be applied either against a Price List or for all Price List.,Procentul de reducere se poate aplica fie pe o listă de prețuri sau pentru toate lista de prețuri.
 DocType: Purchase Invoice,Half-yearly,Semestrial
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +391,Accounting Entry for Stock,Intrare contabilitate pentru stoc
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +399,Accounting Entry for Stock,Intrare contabilitate pentru stoc
 DocType: Vehicle Service,Engine Oil,Ulei de motor
 DocType: Sales Invoice,Sales Team1,Vânzări TEAM1
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +38,Item {0} does not exist,Articolul {0} nu există
 DocType: Attendance Tool Student,Attendance Tool Student,Instrumentul de prezență Student
 DocType: Sales Invoice,Customer Address,Adresă clientului
+DocType: Employee Loan,Loan Details,Creditul Detalii
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Completed Qty must be greater than zero.,Rândul {0}: Completat Cant trebuie să fie mai mare decât zero.
 DocType: Purchase Invoice,Apply Additional Discount On,Aplicați Discount suplimentare La
 DocType: Account,Root Type,Rădăcină Tip
@@ -2498,25 +2665,26 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +158,Extra Small,Extra Small
 DocType: Company,Standard Template,Format standard
 DocType: Training Event,Theory,Teorie
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +706,Warning: Material Requested Qty is less than Minimum Order Qty,Atenție: Materialul solicitat Cant este mai mică decât minima pentru comanda Cantitate
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +757,Warning: Material Requested Qty is less than Minimum Order Qty,Atenție: Materialul solicitat Cant este mai mică decât minima pentru comanda Cantitate
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +212,Account {0} is frozen,Contul {0} este Blocat
 DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Entitate juridică / Filiala cu o Grafic separat de conturi aparținând Organizației.
 DocType: Payment Request,Mute Email,Mute Email
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +29,"Food, Beverage & Tobacco","Produse Alimentare, Bauturi si Tutun"
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +623,Can only make payment against unbilled {0},Poate face doar plata împotriva facturată {0}
-apps/erpnext/erpnext/controllers/selling_controller.py +129,Commission rate cannot be greater than 100,Rata de comision nu poate fi mai mare decat 100
+apps/erpnext/erpnext/controllers/selling_controller.py +131,Commission rate cannot be greater than 100,Rata de comision nu poate fi mai mare decat 100
 DocType: Stock Entry,Subcontract,Subcontract
 apps/erpnext/erpnext/public/js/utils/party.js +161,Please enter {0} first,Va rugam sa introduceti {0} primul
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +64,No replies from,Nu există răspunsuri de la
 DocType: Production Order Operation,Actual End Time,Timp efectiv de sfârşit
 DocType: Production Planning Tool,Download Materials Required,Descărcare Materiale Necesara
-DocType: Item,Manufacturer Part Number,Numarul de piesa
+DocType: Item Manufacturer,Manufacturer Part Number,Numarul de piesa
 DocType: Production Order Operation,Estimated Time and Cost,Timpul estimat și cost
 DocType: Bin,Bin,Coş
 DocType: SMS Log,No of Sent SMS,Nu de SMS-uri trimise
 DocType: Account,Expense Account,Cont de cheltuieli
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +49,Software,Software
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +165,Colour,Culoare
+DocType: Assessment Plan Criteria,Assessment Plan Criteria,Criterii Plan de evaluare
 DocType: Training Event,Scheduled,Programat
 apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Cerere de ofertă.
 apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle",Vă rugăm să selectați postul unde &quot;Este Piesa&quot; este &quot;nu&quot; și &quot;Este punctul de vânzare&quot; este &quot;da&quot; și nu este nici un alt produs Bundle
@@ -2532,12 +2700,16 @@
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Data de începere a proiectului
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +8,Until,Până la
 DocType: Rename Tool,Rename Log,Redenumi Conectare
+DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Menținerea Ore de facturare și orele de lucru Aceleași pe Pontaj
 DocType: Maintenance Visit Purpose,Against Document No,Împotriva documentul nr
 DocType: BOM,Scrap,Resturi
 apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Gestiona vânzările Partners.
 DocType: Quality Inspection,Inspection Type,Inspecție Tip
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +225,Warehouses with existing transaction can not be converted to group.,Depozite tranzacție existente nu pot fi convertite în grup.
-apps/erpnext/erpnext/controllers/recurring_document.py +166,Please select {0},Vă rugăm să selectați {0}
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +237,Warehouses with existing transaction can not be converted to group.,Depozite tranzacție existente nu pot fi convertite în grup.
+DocType: Assessment Result Tool,Result HTML,rezultat HTML
+apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Expira la
+apps/erpnext/erpnext/utilities/activation.py +118,Add Students,Adăugați studenți
+apps/erpnext/erpnext/controllers/recurring_document.py +169,Please select {0},Vă rugăm să selectați {0}
 DocType: C-Form,C-Form No,Nr. formular-C
 DocType: BOM,Exploded_items,Exploded_items
 DocType: Employee Attendance Tool,Unmarked Attendance,Participarea nemarcat
@@ -2552,13 +2724,14 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +295,Serial No {0} created,Serial Nu {0} a creat
 DocType: Homepage,Company Description for website homepage,Descriere companie pentru pagina de start site
 DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pentru comoditatea clienților, aceste coduri pot fi utilizate în formate de imprimare cum ar fi Facturi și Note de Livrare"
+apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,Nume furnizo
 DocType: Sales Invoice,Time Sheet List,Listă de timp Sheet
 DocType: Employee,You can enter any date manually,Puteți introduce manual orice dată
 DocType: Asset Category Account,Depreciation Expense Account,Contul de amortizare de cheltuieli
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +183,Probationary Period,Perioadă De Probă
 DocType: Customer Group,Only leaf nodes are allowed in transaction,Numai noduri frunze sunt permise în tranzacție
 DocType: Expense Claim,Expense Approver,Cheltuieli aprobator
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +129,Row {0}: Advance against Customer must be credit,Row {0}: avans Clientul trebuie să fie de credit
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +124,Row {0}: Advance against Customer must be credit,Row {0}: avans Clientul trebuie să fie de credit
 apps/erpnext/erpnext/accounts/doctype/account/account.js +66,Non-Group to Group,Non-Grup la Grup
 DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Primirea de cumpărare Articol Livrat
 DocType: Payment Entry,Pay,Plăti
@@ -2571,7 +2744,6 @@
 DocType: Item,Inspection Required before Delivery,Necesar de inspecție înainte de livrare
 DocType: Item,Inspection Required before Purchase,Necesar de inspecție înainte de achiziționare
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Activități în curs
-DocType: Payment Gateway,Gateway,Portal
 DocType: Fee Component,Fees Category,Taxele de Categoria
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +129,Please enter relieving date.,Vă rugăm să introduceți data alinarea.
 apps/erpnext/erpnext/controllers/trends.py +149,Amt,Amt
@@ -2599,6 +2771,7 @@
 apps/erpnext/erpnext/controllers/status_updater.py +198,Limit Crossed,limita Traversat
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +55,Venture Capital,Capital de Risc
 apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Un termen academic cu acest &quot;An universitar&quot; {0} și &quot;Numele Termenul&quot; {1} există deja. Vă rugăm să modificați aceste intrări și încercați din nou.
+apps/erpnext/erpnext/stock/doctype/item/item.py +466,"As there are existing transactions against item {0}, you can not change the value of {1}","Deoarece există tranzacții existente la postul {0}, nu puteți modifica valoarea {1}"
 DocType: UOM,Must be Whole Number,Trebuie să fie Număr întreg
 DocType: Leave Control Panel,New Leaves Allocated (In Days),Cereri noi de concediu alocate (în zile)
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,Serial Nu {0} nu există
@@ -2615,13 +2788,14 @@
 ,Issued Items Against Production Order,Emise Articole împotriva producției de comandă
 DocType: Target Detail,Target Detail,Țintă Detaliu
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,toate locurile de muncă
-DocType: Sales Order,% of materials billed against this Sales Order,% 재료가 이 주문을 위해 청구됨
+DocType: Sales Order,% of materials billed against this Sales Order,% de materiale facturate versus comanda aceasta
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Intrarea Perioada de închidere
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Centrul de Cost cu tranzacții existente nu poate fi transformat în grup
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +333,Amount {0} {1} {2} {3},Suma {0} {1} {2} {3}
 DocType: Account,Depreciation,Depreciere
 apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Furnizor (e)
 DocType: Employee Attendance Tool,Employee Attendance Tool,Instrumentul Participarea angajat
+DocType: Guardian Student,Guardian Student,Guardian Student
 DocType: Supplier,Credit Limit,Limita de Credit
 DocType: Production Plan Sales Order,Salse Order Date,Salse Data comenzii
 DocType: Salary Component,Salary Component,Componenta de salarizare
@@ -2635,8 +2809,9 @@
 apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Șablon de termeni sau contractului.
 DocType: Purchase Invoice,Address and Contact,Adresa si Contact
 DocType: Cheque Print Template,Is Account Payable,Este cont de plati
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +261,Stock cannot be updated against Purchase Receipt {0},Stock nu poate fi actualizat cu confirmare de primire {0} Purchase
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +269,Stock cannot be updated against Purchase Receipt {0},Stock nu poate fi actualizat cu confirmare de primire {0} Purchase
 DocType: Supplier,Last Day of the Next Month,Ultima zi a lunii următoare
+DocType: Support Settings,Auto close Issue after 7 days,Auto închidere Problemă după 7 zile
 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}","Concediu nu poate fi repartizat înainte {0}, ca echilibru concediu a fost deja carry transmise în viitor înregistrarea alocare concediu {1}"
 apps/erpnext/erpnext/accounts/party.py +302,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Notă: Datorită / Reference Data depășește de companie zile de credit client de {0} zi (le)
 apps/erpnext/erpnext/schools/doctype/program/program.js +9,Student Applicant,Solicitantul elev
@@ -2653,14 +2828,14 @@
 DocType: Quality Inspection,Outgoing,Trimise
 DocType: Material Request,Requested For,Pentru a solicitat
 DocType: Quotation Item,Against Doctype,Comparativ tipului documentului
-apps/erpnext/erpnext/controllers/buying_controller.py +380,{0} {1} is cancelled or closed,{0} {1} este anulat sau închis
+apps/erpnext/erpnext/controllers/buying_controller.py +391,{0} {1} is cancelled or closed,{0} {1} este anulat sau închis
 DocType: Delivery Note,Track this Delivery Note against any Project,Urmareste acest Livrare Note împotriva oricărui proiect
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +30,Net Cash from Investing,Numerar net din Investiții
 ,Is Primary Address,Este primar Adresa
 DocType: Production Order,Work-in-Progress Warehouse,De lucru-in-Progress Warehouse
 apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +104,Asset {0} must be submitted,Activ {0} trebuie depuse
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +61,Attendance Record {0} exists against Student {1},Prezență record {0} există împotriva elevului {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +347,Reference #{0} dated {1},Reference # {0} din {1}
+apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +62,Attendance Record {0} exists against Student {1},Prezență record {0} există împotriva elevului {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +342,Reference #{0} dated {1},Reference # {0} din {1}
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +161,Depreciation Eliminated due to disposal of assets,Amortizare Eliminată din cauza eliminării activelor
 apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Gestionați Adrese
 DocType: Asset,Item Code,Cod articol
@@ -2670,7 +2845,7 @@
 DocType: Lead,Market Segment,Segmentul de piață
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +867,Paid Amount cannot be greater than total negative outstanding amount {0},Suma plătită nu poate fi mai mare decât suma totală negativă restante {0}
 DocType: Employee Internal Work History,Employee Internal Work History,Istoric Intern Locuri de Munca Angajat
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +235,Closing (Dr),De închidere (Dr)
+apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +238,Closing (Dr),De închidere (Dr)
 DocType: Cheque Print Template,Cheque Size,Dimensiune cecului
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +228,Serial No {0} not in stock,Serial Nu {0} nu este în stoc
 apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Șablon impozit pentru tranzacțiile de vânzare.
@@ -2678,6 +2853,7 @@
 DocType: Student Batch Creation Tool,Student Batch Creation Tool,Instrumentul de student Crearea de lot
 DocType: Stock Settings,Default Stock UOM,Stoc UOM Implicit
 DocType: Asset,Number of Depreciations Booked,Numărul de Deprecieri rezervat
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Împotriva angajaților Loan: {0}
 DocType: Landed Cost Item,Receipt Document,Documentul de primire
 DocType: Production Planning Tool,Create Material Requests,Creare Necesar de Materiale
 DocType: Employee Education,School/University,Școlar / universitar
@@ -2686,30 +2862,35 @@
 DocType: Sales Invoice Item,Available Qty at Warehouse,Cantitate disponibilă în depozit
 apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Sumă facturată
 DocType: Asset,Double Declining Balance,Dublu degresive
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +166,Closed order cannot be cancelled. Unclose to cancel.,Pentru închis nu poate fi anulată. Pentru a anula redeschide.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +170,Closed order cannot be cancelled. Unclose to cancel.,Pentru închis nu poate fi anulată. Pentru a anula redeschide.
 DocType: Student Guardian,Father,tată
 apps/erpnext/erpnext/controllers/accounts_controller.py +568,'Update Stock' cannot be checked for fixed asset sale,&quot;Actualizare stoc&quot; nu poate fi verificată de vânzare de active fixe
 DocType: Bank Reconciliation,Bank Reconciliation,Reconciliere bancară
+DocType: Attendance,On Leave,La plecare
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Obțineți actualizări
 apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +97,{0} {1}: Account {2} does not belong to Company {3},{0} {1}: Cont {2} nu aparține Companiei {3}
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +132,Material Request {0} is cancelled or stopped,Cerere de material {0} este anulată sau oprită
 apps/erpnext/erpnext/public/js/setup_wizard.js +318,Add a few sample records,Adaugă câteva înregistrări eșantion
-apps/erpnext/erpnext/config/hr.py +304,Leave Management,Lasă Managementul
+apps/erpnext/erpnext/config/hr.py +301,Leave Management,Lasă Managementul
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +87,Group by Account,Grup in functie de Cont
 DocType: Sales Order,Fully Delivered,Livrat complet
 DocType: Lead,Lower Income,Micsoreaza Venit
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +160,Source and target warehouse cannot be same for row {0},Sursă și depozit țintă nu poate fi același pentru rând {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","Diferența cont trebuie să fie un cont de tip activ / pasiv, deoarece acest stoc Reconcilierea este un intrare de deschidere"
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +85,Purchase Order number required for Item {0},Număr de comandă de aprovizionare necesare pentru postul {0}
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Suma debursate nu poate fi mai mare decât Suma creditului {0}
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +86,Purchase Order number required for Item {0},Număr de comandă de aprovizionare necesare pentru postul {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +871,Production Order not created,Comanda de producție nu a fost creat
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date','Din Data' trebuie să fie dupã 'Până în Data'
 apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.py +29,Cannot change status as student {0} is linked with student application {1},Nu se poate schimba statutul de student ca {0} este legat cu aplicația de student {1}
 DocType: Asset,Fully Depreciated,Depreciata pe deplin
 ,Stock Projected Qty,Stoc proiectată Cantitate
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +390,Customer {0} does not belong to project {1},Clientul {0} nu apartine proiectului {1}
 DocType: Employee Attendance Tool,Marked Attendance HTML,Participarea marcat HTML
+apps/erpnext/erpnext/utilities/activation.py +74,"Quotations are proposals, bids you have sent to your customers","Cotațiile sunt propuneri, sumele licitate le-ați trimis clienților dvs."
 DocType: Sales Order,Customer's Purchase Order,Comandă clientului
 apps/erpnext/erpnext/config/stock.py +112,Serial No and Batch,Serial și Lot nr
 DocType: Warranty Claim,From Company,De la Compania
+apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +52,Sum of Scores of Assessment Criteria needs to be {0}.,Suma Scorurile de criterii de evaluare trebuie să fie {0}.
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +76,Please set Number of Depreciations Booked,Vă rugăm să setați Numărul de Deprecieri rezervat
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +95,Value or Qty,Valoare sau Cantitate
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +402,Productions Orders cannot be raised for:,Comenzile Productions nu pot fi ridicate pentru:
@@ -2717,14 +2898,15 @@
 DocType: Purchase Invoice,Purchase Taxes and Charges,Taxele de cumpărare și Taxe
 ,Qty to Receive,Cantitate de a primi
 DocType: Leave Block List,Leave Block List Allowed,Lista Concedii Blocate Permise
+DocType: Grading Scale Interval,Grading Scale Interval,Clasificarea Scala Interval
 apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Revendicarea pentru cheltuieli de vehicul Log {0}
 apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +58,All Warehouses,toate Depozite
 DocType: Sales Partner,Retailer,Vânzător cu amănuntul
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Credit To account must be a Balance Sheet account,Credit în contul trebuie să fie un cont de bilanț
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +107,Credit To account must be a Balance Sheet account,Credit în contul trebuie să fie un cont de bilanț
 apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +128,All Supplier Types,Toate tipurile de furnizor
 DocType: Global Defaults,Disable In Words,Nu fi de acord în cuvinte
 apps/erpnext/erpnext/stock/doctype/item/item.py +44,Item Code is mandatory because Item is not automatically numbered,"Cod articol este obligatorie, deoarece postul nu este numerotat automat"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +97,Quotation {0} not of type {1},Citat {0} nu de tip {1}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +101,Quotation {0} not of type {1},Citat {0} nu de tip {1}
 DocType: Maintenance Schedule Item,Maintenance Schedule Item,Articol Program Mentenanta
 DocType: Sales Order,%  Delivered,% Livrat
 DocType: Production Order,PRO-,PRO-
@@ -2732,6 +2914,7 @@
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Realizeaza Fluturas de Salar
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +28,Browse BOM,Navigare BOM
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +153,Secured Loans,Împrumuturi garantate
+DocType: Purchase Invoice,Edit Posting Date and Time,Editare postare Data și ora
 apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +94,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Vă rugăm să setați Conturi aferente amortizării în categoria activelor {0} sau companie {1}
 DocType: Academic Term,Academic Year,An academic
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +167,Opening Balance Equity,Sold Equity
@@ -2746,6 +2929,7 @@
 DocType: Project,Total Purchase Cost (via Purchase Invoice),Cost total de achiziție (prin cumparare factură)
 DocType: Training Event,Start Time,Ora de începere
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +261,Select Quantity,Selectați Cantitate
+DocType: Customs Tariff Number,Customs Tariff Number,Tariful vamal Număr
 apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Aprobarea unui rol nu poate fi aceeaşi cu rolul. Regula este aplicabilă pentru
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +65,Unsubscribe from this Email Digest,Dezabona de la acest e-mail Digest
 apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Mesajul a fost trimis
@@ -2767,8 +2951,9 @@
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Nu este permis să actualizeze tranzacțiile bursiere mai vechi de {0}
 DocType: Purchase Invoice Item,PR Detail,PR Detaliu
 DocType: Sales Order,Fully Billed,Complet Taxat
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +149,Please set default payable account in the employee {0},Vă rugăm să setați implicit cont de plătit în angajatului {0}
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Bani în mână
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +123,Delivery warehouse required for stock item {0},Depozit de livrare necesar pentru articol stoc {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +127,Delivery warehouse required for stock item {0},Depozit de livrare necesar pentru articol stoc {0}
 DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),"Greutatea brută a pachetului. Greutate + ambalare, de obicei, greutate netă de material. (Pentru imprimare)"
 apps/erpnext/erpnext/schools/doctype/course/course.js +3,Program,Program
 DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Utilizatorii cu acest rol li se permite să stabilească în conturile înghețate și de a crea / modifica intrări contabile împotriva conturile înghețate
@@ -2797,20 +2982,23 @@
 ,Welcome to ERPNext,Bine ati venit la ERPNext
 apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Duce la ofertă
 DocType: Lead,From Customer,De la Client
-apps/erpnext/erpnext/demo/setup/setup_data.py +313,Calls,Apeluri
+apps/erpnext/erpnext/demo/setup/setup_data.py +314,Calls,Apeluri
 DocType: Project,Total Costing Amount (via Time Logs),Suma totală Costing (prin timp Busteni)
 DocType: Purchase Order Item Supplied,Stock UOM,Stoc UOM
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +218,Purchase Order {0} is not submitted,Comandă {0} nu este prezentat
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Purchase Order {0} is not submitted,Comandă {0} nu este prezentat
+DocType: Customs Tariff Number,Tariff Number,Tarif Număr
 apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,Proiectat
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +218,Serial No {0} does not belong to Warehouse {1},Serial Nu {0} nu apartine Warehouse {1}
 apps/erpnext/erpnext/controllers/status_updater.py +162,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,"Notă: Sistemul nu va verifica peste, livrare și supra-rezervări pentru postul {0} ca și cantitatea sau valoarea este 0"
 DocType: Notification Control,Quotation Message,Citat Mesaj
+DocType: Employee Loan,Employee Loan Application,Cererea de împrumut Angajat
 DocType: Issue,Opening Date,Data deschiderii
-apps/erpnext/erpnext/schools/api.py +67,Attendance has been marked successfully.,Prezență a fost marcată cu succes.
+apps/erpnext/erpnext/schools/api.py +69,Attendance has been marked successfully.,Prezență a fost marcată cu succes.
 DocType: Journal Entry,Remark,Remarcă
 DocType: Purchase Receipt Item,Rate and Amount,Rata și volumul
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +146,Account Type for {0} must be {1},Tipul de cont pentru {0} trebuie să fie {1}
 apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Frunze și de vacanță
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +49,Customer &gt; Customer Group &gt; Territory,Clienți&gt; Clienți Grup&gt; Teritoriu
 DocType: Sales Order,Not Billed,Nu Taxat
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +147,Both Warehouse must belong to same Company,Ambele depozite trebuie să aparțină aceleiași companii
 apps/erpnext/erpnext/public/js/templates/contact_list.html +37,No contacts added yet.,Nu contact adăugat încă.
@@ -2820,6 +3008,7 @@
 apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Reducere Suma
 DocType: Purchase Invoice,Return Against Purchase Invoice,Reveni Împotriva cumparare factură
 DocType: Item,Warranty Period (in days),Perioada de garanție (în zile)
+apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +50,Relation with Guardian1,Relația cu Guardian1
 apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Acutal qty in stock,Cantitate acutal în stoc
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +18,Net Cash from Operations,Numerar net din operațiuni
 apps/erpnext/erpnext/public/js/setup_wizard.js +230,e.g. VAT,"de exemplu, TVA"
@@ -2830,14 +3019,17 @@
 apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.js +3,Student Group,Grupul studențesc
 DocType: Shopping Cart Settings,Quotation Series,Ofertă Series
 apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +58,"An item exists with same name ({0}), please change the item group name or rename the item","Există un articol cu aceeaşi denumire ({0}), vă rugăm să schimbați denumirea grupului articolului sau să redenumiţi articolul"
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1542,Please select customer,Vă rugăm să selectați Clienți
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1868,Please select customer,Vă rugăm să selectați Clienți
 DocType: C-Form,I,eu
 DocType: Company,Asset Depreciation Cost Center,Amortizarea activului Centru de cost
 DocType: Sales Order Item,Sales Order Date,Comandă de vânzări Data
 DocType: Sales Invoice Item,Delivered Qty,Cantitate Livrata
 DocType: Production Planning Tool,"If checked, all the children of each production item will be included in the Material Requests.","Dacă este bifată, toți copiii fiecărui element de producție vor fi incluse în Cererile materiale."
+DocType: Assessment Plan,Assessment Plan,Plan de evaluare
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +90,Warehouse {0}: Company is mandatory,Depozit {0}: Compania este obligatorie
+DocType: Stock Settings,Limit Percent,Limita procentuală
 ,Payment Period Based On Invoice Date,Perioada de plată Bazat pe Data facturii
+apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +46,Item Code &gt; Item Group &gt; Brand,Articol Cod&gt; Grupa de articole&gt; Marca
 apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Lipsește Schimb valutar prețul pentru {0}
 DocType: Assessment Plan,Examiner,Examinator
 DocType: Student,Siblings,siblings
@@ -2846,10 +3038,11 @@
 DocType: C-Form,C-FORM-,C-forma-
 DocType: Vehicle,Insurance Details,Detalii de asigurare
 DocType: Account,Payable,Plătibil
-apps/erpnext/erpnext/shopping_cart/cart.py +350,Debtors ({0}),Debitorilor ({0})
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Vă rugăm să introduceți perioada de rambursare
+apps/erpnext/erpnext/shopping_cart/cart.py +354,Debtors ({0}),Debitorilor ({0})
 DocType: Pricing Rule,Margin,Margin
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Clienți noi
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Gross Profit %,Profit Brut%
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Gross Profit %,Profit Brut%
 DocType: Appraisal Goal,Weightage (%),Weightage (%)
 DocType: Bank Reconciliation Detail,Clearance Date,Data Aprobare
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +61,Gross Purchase Amount is mandatory,Valoarea brută Achiziția este obligatorie
@@ -2869,12 +3062,14 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +47,Min Qty can not be greater than Max Qty,Min Cantitate nu poate fi mai mare decât Max Cantitate
 DocType: Account,Accumulated Depreciation,Amortizarea cumulată
 DocType: Stock Entry,Customer or Supplier Details,Client sau furnizor Detalii
+DocType: Employee Loan Application,Required by Date,Necesar de către Data
 DocType: Lead,Lead Owner,Proprietar Conducere
 DocType: Bin,Requested Quantity,Cantitatea solicitată
 DocType: Employee,Marital Status,Stare civilă
 DocType: Stock Settings,Auto Material Request,Auto cerere de material
 DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Disponibil lot Cantitate puțin din Warehouse
 DocType: Customer,CUST-,CUST-
+DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Plata brută - Deducerea totală - rambursare a creditului
 apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +25,Current BOM and New BOM can not be same,FDM-ul curent și FDM-ul nou nu pot fi identici
 apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +38,Salary Slip ID,ID-ul de salarizare alunecare
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Date Of Retirement must be greater than Date of Joining,Data Pensionare trebuie să fie ulterioara Datei Aderării
@@ -2883,12 +3078,13 @@
 apps/erpnext/erpnext/controllers/website_list_for_contact.py +90,{0}% Delivered,{0}% Livrat
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +79,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,Postul {0}: Cantitate comandat {1} nu poate fi mai mică de cantitate minimă de comandă {2} (definită la punctul).
 DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Lunar Procentaj Distribuție
+apps/erpnext/erpnext/hr/doctype/employee/employee.py +23,Please setup Employee Naming System in Human Resource &gt; HR Settings,Vă rugăm să Configurarea angajaților sistemului de denumiri în resurse umane&gt; Setări HR
 DocType: Territory,Territory Targets,Obiective Territory
 DocType: Delivery Note,Transporter Info,Info Transporter
 apps/erpnext/erpnext/accounts/utils.py +501,Please set default {0} in Company {1},Vă rugăm să setați implicit {0} în {1} companie
 DocType: Cheque Print Template,Starting position from top edge,Poziția de la muchia superioară de pornire
 apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +29,Same supplier has been entered multiple times,Același furnizor a fost introdus de mai multe ori
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +148,Gross Profit / Loss,Profit brut / Pierdere
+apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Profit brut / Pierdere
 DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Comandă de aprovizionare Articol Livrat
 apps/erpnext/erpnext/public/js/setup_wizard.js +83,Company Name cannot be Company,Numele companiei nu poate fi companie
 apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,Antete de Scrisoare de Sabloane de Imprimare.
@@ -2944,18 +3140,19 @@
 apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Șabloanele țară înțelept adresa implicită
 DocType: Sales Order Item,Supplier delivers to Customer,Furnizor livrează la client
 apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (# Forma / Postul / {0}) este din stoc
-apps/erpnext/erpnext/controllers/recurring_document.py +174,Next Date must be greater than Posting Date,Următoarea dată trebuie să fie mai mare de postare Data
-apps/erpnext/erpnext/public/js/controllers/transaction.js +880,Show tax break-up,Arată impozit break-up
+apps/erpnext/erpnext/controllers/recurring_document.py +177,Next Date must be greater than Posting Date,Următoarea dată trebuie să fie mai mare de postare Data
+apps/erpnext/erpnext/public/js/controllers/transaction.js +914,Show tax break-up,Arată impozit break-up
 apps/erpnext/erpnext/accounts/party.py +305,Due / Reference Date cannot be after {0},Datorită / Reference Data nu poate fi după {0}
 apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Datele de import și export
 apps/erpnext/erpnext/accounts/doctype/account/account.py +204,"Stock entries exist against Warehouse {0}, hence you cannot re-assign or modify it","intrările de stoc există împotriva Warehouse {0}, prin urmare, nu se poate re-atribui sau modifica"
-apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +29,No students Found,Nu există elevi găsit
+apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +39,No students Found,Nu există elevi găsit
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Postarea factură Data
 apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Vinde
 DocType: Sales Invoice,Rounded Total,Rotunjite total
 DocType: Product Bundle,List items that form the package.,Listeaza articole care formează pachetul.
 apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Alocarea procent ar trebui să fie egală cu 100%
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +530,Please select Posting Date before selecting Party,Vă rugăm să selectați Dată postare înainte de a selecta Parte
+DocType: Program Enrollment,School House,School House
 DocType: Serial No,Out of AMC,Din AMC
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +81,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Numărul de Deprecieri Booked nu poate fi mai mare decât Număr total de Deprecieri
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +45,Make Maintenance Visit,Realizeaza Vizita de Mentenanta
@@ -2964,9 +3161,9 @@
 apps/erpnext/erpnext/config/accounts.py +56,Company (not Customer or Supplier) master.,Directorul Companiei(nu al Clientului sau al Furnizorui).
 apps/erpnext/erpnext/schools/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Aceasta se bazează pe prezența acestui student
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +166,Add more items or open full form,Adăugați mai multe elemente sau sub formă deschis complet
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +104,Please enter 'Expected Delivery Date',"Vă rugăm să introduceți ""Data de livrare așteptată"""
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +184,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Nota de Livrare {0} trebuie sa fie anulată înainte de a anula aceasta Comandă de Vânzări
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +76,Paid amount + Write Off Amount can not be greater than Grand Total,Suma plătită + Scrie Off Suma nu poate fi mai mare decât Grand total
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +108,Please enter 'Expected Delivery Date',"Vă rugăm să introduceți ""Data de livrare așteptată"""
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +197,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Nota de Livrare {0} trebuie sa fie anulată înainte de a anula aceasta Comandă de Vânzări
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +77,Paid amount + Write Off Amount can not be greater than Grand Total,Suma plătită + Scrie Off Suma nu poate fi mai mare decât 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} nu este un număr de lot valid aferent articolului {1}
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Note: There is not enough leave balance for Leave Type {0},Notă: Nu este echilibrul concediu suficient pentru concediul de tip {0}
 DocType: Training Event,Seminar,Seminar
@@ -2984,7 +3181,8 @@
 DocType: Company,Create Chart Of Accounts Based On,"Creează Plan de conturi, bazate pe"
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date of Birth cannot be greater than today.,Data nașterii nu poate fi mai mare decât în prezent.
 ,Stock Ageing,Stoc Îmbătrânirea
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +128,Timesheet,pontajul
+apps/erpnext/erpnext/schools/doctype/student/student.py +38,Student {0} exist against student applicant {1},Student {0} există împotriva solicitantului de student {1}
+apps/erpnext/erpnext/projects/doctype/task/task.js +31,Timesheet,pontajul
 apps/erpnext/erpnext/controllers/accounts_controller.py +241,{0} '{1}' is disabled,{0} '{1}' este dezactivat
 apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Setați ca Deschis
 DocType: Cheque Print Template,Scanned Cheque,scanate cecului
@@ -3010,56 +3208,63 @@
 DocType: Sales Order,Partly Billed,Parțial Taxat
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +42,Item {0} must be a Fixed Asset Item,Postul {0} trebuie să fie un element activ fix
 DocType: Item,Default BOM,FDM Implicit
-apps/erpnext/erpnext/setup/doctype/company/company.js +44,Please re-type company name to confirm,Vă rugăm să re-tip numele companiei pentru a confirma
+apps/erpnext/erpnext/setup/doctype/company/company.js +45,Please re-type company name to confirm,Vă rugăm să re-tip numele companiei pentru a confirma
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +67,Total Outstanding Amt,Totală restantă Amt
 DocType: Journal Entry,Printing Settings,Setări de imprimare
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +285,Total Debit must be equal to Total Credit. The difference is {0},Totală de debit trebuie să fie egal cu total Credit. Diferența este {0}
+DocType: Sales Invoice,Include Payment (POS),Include de plată (POS)
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +280,Total Debit must be equal to Total Credit. The difference is {0},Totală de debit trebuie să fie egal cu total Credit. Diferența este {0}
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +11,Automotive,Autopropulsat
 DocType: Vehicle,Insurance Company,Companie de asigurari
 DocType: Asset Category Account,Fixed Asset Account,Cont activ fix
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +388,Variable,Variabil
 apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +46,From Delivery Note,Din Nota de Livrare
+DocType: Student,Student Email Address,Adresa de e-mail Student
 DocType: Timesheet Detail,From Time,Din Time
+apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,In stoc:
 DocType: Notification Control,Custom Message,Mesaj Personalizat
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +33,Investment Banking,Investment Banking
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +72,Cash or Bank Account is mandatory for making payment entry,Pentru a face o inregistrare de plată este obligatoriu numerar sau cont bancar
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +73,Cash or Bank Account is mandatory for making payment entry,Pentru a face o inregistrare de plată este obligatoriu numerar sau cont bancar
 DocType: Purchase Invoice,Price List Exchange Rate,Lista de prețuri Cursul de schimb
 DocType: Purchase Invoice Item,Rate,
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +66,Intern,Interna
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1438,Address Name,Numele adresei
 DocType: Stock Entry,From BOM,De la BOM
 DocType: Assessment Code,Assessment Code,Codul de evaluare
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +35,Basic,Elementar
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Tranzacțiilor bursiere înainte de {0} sunt înghețate
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +220,Please click on 'Generate Schedule',"Vă rugăm să faceți clic pe ""Generate Program"""
 apps/erpnext/erpnext/config/stock.py +190,"e.g. Kg, Unit, Nos, m","de exemplu, Kg, Unitatea, nr, m"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +115,Reference No is mandatory if you entered Reference Date,De referință nu este obligatorie în cazul în care ați introdus Reference Data
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +110,Reference No is mandatory if you entered Reference Date,De referință nu este obligatorie în cazul în care ați introdus Reference Data
 DocType: Bank Reconciliation Detail,Payment Document,Documentul de plată
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +110,Date of Joining must be greater than Date of Birth,Data Aderării trebuie să fie ulterioara Datei Nașterii
 DocType: Salary Slip,Salary Structure,Structura salariu
 DocType: Account,Bank,Bancă
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +9,Airline,Linie aeriană
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +739,Issue Material,Eliberarea Material
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +790,Issue Material,Eliberarea Material
 DocType: Material Request Item,For Warehouse,Pentru Depozit
 DocType: Employee,Offer Date,Oferta Date
 apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Cotațiile
-apps/erpnext/erpnext/accounts/page/pos/pos.js +663,You are in offline mode. You will not be able to reload until you have network.,Sunteți în modul offline. Tu nu va fi capabil să reîncărcați până când nu aveți de rețea.
+apps/erpnext/erpnext/accounts/page/pos/pos.js +665,You are in offline mode. You will not be able to reload until you have network.,Sunteți în modul offline. Tu nu va fi capabil să reîncărcați până când nu aveți de rețea.
 apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +31,No Student Groups created.,Nu există grupuri create de studenți.
 DocType: Purchase Invoice Item,Serial No,Nr. serie
+apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Rambursarea lunară Suma nu poate fi mai mare decât Suma creditului
 apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +144,Please enter Maintaince Details first,Va rugam sa introduceti maintaince detaliile prima
 DocType: Purchase Invoice,Print Language,Limba de imprimare
 DocType: Salary Slip,Total Working Hours,Numărul total de ore de lucru
 DocType: Stock Entry,Including items for sub assemblies,Inclusiv articole pentru subansambluri
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1474,Enter value must be positive,Introduceți valoarea trebuie să fie pozitiv
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1797,Enter value must be positive,Introduceți valoarea trebuie să fie pozitiv
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +102,All Territories,Toate teritoriile
 DocType: Purchase Invoice,Items,Articole
 apps/erpnext/erpnext/schools/doctype/program_enrollment/program_enrollment.py +25,Student is already enrolled.,Student este deja înscris.
 DocType: Fiscal Year,Year Name,An Denumire
 DocType: Process Payroll,Process Payroll,Salarizare proces
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +221,There are more holidays than working days this month.,Există mai multe sărbători decât de zile de lucru în această lună.
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +234,There are more holidays than working days this month.,Există mai multe sărbători decât de zile de lucru în această lună.
 DocType: Product Bundle Item,Product Bundle Item,Produs Bundle Postul
 DocType: Sales Partner,Sales Partner Name,Numele Partner Sales
-apps/erpnext/erpnext/hooks.py +105,Request for Quotations,Cerere de Cotațiile
+apps/erpnext/erpnext/hooks.py +111,Request for Quotations,Cerere de Cotațiile
 DocType: Payment Reconciliation,Maximum Invoice Amount,Factură maxim Suma
+DocType: Item,Device Package Code,Dispozitiv cu cod
+DocType: Student Language,Student Language,Limba Student
 apps/erpnext/erpnext/config/selling.py +23,Customers,clienţii care
 DocType: Student Sibling,Institution,Instituţie
 DocType: Asset,Partially Depreciated,parțial Depreciata
@@ -3069,6 +3274,7 @@
 apps/erpnext/erpnext/stock/doctype/item/item.py +642,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',Unitatea implicit de măsură pentru Variant &#39;{0} &quot;trebuie să fie la fel ca în Template&quot; {1} &quot;
 DocType: Shipping Rule,Calculate Based On,Calculaţi pe baza
 DocType: Delivery Note Item,From Warehouse,Din depozitul
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +872,No Items with Bill of Materials to Manufacture,Nu există niciun articol cu Lista de materiale pentru fabricarea
 DocType: Assessment Plan,Supervisor Name,Nume supervizor
 DocType: Grading Structure,Grading Structure,Structura de notare
 DocType: Purchase Taxes and Charges,Valuation and Total,Evaluare și Total
@@ -3100,6 +3306,7 @@
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Centrul de Cost cu tranzacții existente nu poate fi transformat în registru contabil
 DocType: Department,Days for which Holidays are blocked for this department.,Zile pentru care Sărbătorile sunt blocate pentru acest departament.
 ,Produced,Produs
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +121,Created Salary Slips,Creat Alunecările salariale
 DocType: Item,Item Code for Suppliers,Articol Cod pentru Furnizori
 DocType: Issue,Raised By (Email),Ridicate de (e-mail)
 DocType: Training Event,Trainer Name,Nume formator
@@ -3121,6 +3328,7 @@
 apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Total (Amt)
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +26,Entertainment & Leisure,Divertisment & Relaxare
 DocType: Quality Inspection,Item Serial No,Nr. de Serie Articol
+apps/erpnext/erpnext/utilities/activation.py +136,Create Employee Records,Crearea angajaților Records
 apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +58,Total Present,Raport Prezent
 apps/erpnext/erpnext/config/accounts.py +107,Accounting Statements,Declarațiile contabile
 apps/erpnext/erpnext/public/js/setup_wizard.js +304,Hour,Oră
@@ -3130,7 +3338,7 @@
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Noua ordine nu pot avea Warehouse. Depozit trebuie să fie stabilite de către Bursa de intrare sau de primire de cumparare
 DocType: Lead,Lead Type,Tip Conducere
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133,You are not authorized to approve leaves on Block Dates,Tu nu sunt autorizate să aprobe frunze pe bloc Perioada
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +362,All these items have already been invoiced,Toate aceste articole au fost deja facturate
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +364,All these items have already been invoiced,Toate aceste articole au fost deja facturate
 apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Poate fi aprobat/a de către {0}
 DocType: Item,Default Material Request Type,Implicit Material Tip de solicitare
 apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +7,Unknown,Necunoscut
@@ -3146,17 +3354,20 @@
 DocType: Student,Middle Name,Al doilea nume
 DocType: C-Form,Invoices,Facturi
 DocType: Job Opening,Job Title,Denumire post
+apps/erpnext/erpnext/utilities/activation.py +100,Create Users,Creați Utilizatori
 apps/erpnext/erpnext/public/js/setup_wizard.js +304,Gram,Gram
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +375,Quantity to Manufacture must be greater than 0.,Cantitatea să Fabricare trebuie sa fie mai mare decât 0.
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +393,Quantity to Manufacture must be greater than 0.,Cantitatea să Fabricare trebuie sa fie mai mare decât 0.
 apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Vizitați raport de apel de întreținere.
 DocType: Stock Entry,Update Rate and Availability,Actualizarea Rata și disponibilitatea
 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.,"Procentul vi se permite de a primi sau livra mai mult față de cantitatea comandata. De exemplu: Dacă ați comandat 100 de unități. și alocația este de 10%, atunci vi se permite să primească 110 de unități."
 DocType: POS Customer Group,Customer Group,Grup Client
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +186,Expense account is mandatory for item {0},Cont de cheltuieli este obligatoriu pentru articolul {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +194,Expense account is mandatory for item {0},Cont de cheltuieli este obligatoriu pentru articolul {0}
 DocType: BOM,Website Description,Site-ul Descriere
 apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +42,Net Change in Equity,Schimbarea net în capitaluri proprii
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +152,Please cancel Purchase Invoice {0} first,Vă rugăm să anulați Achiziționarea factură {0} mai întâi
+apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +42,"Email Address must be unique, already exists for {0}","Adresa de e-mail trebuie să fie unic, există deja pentru {0}"
 DocType: Serial No,AMC Expiry Date,Dată expirare AMC
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +795,Receipt,primire
 ,Sales Register,Vânzări Inregistrare
 DocType: Daily Work Summary Settings Company,Send Emails At,Trimite email-uri La
 DocType: Quotation,Quotation Lost Reason,Citat pierdut rațiunea
@@ -3166,13 +3377,14 @@
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +117,Summary for this month and pending activities,Rezumat pentru această lună și activități în așteptarea
 DocType: Customer Group,Customer Group Name,Nume Group Client
 apps/erpnext/erpnext/public/js/financial_statements.js +55,Cash Flow Statement,Situația fluxurilor de trezorerie
+apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Suma creditului nu poate depăși valoarea maximă a împrumutului de {0}
 apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +21,License,Licență
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +437,Please remove this Invoice {0} from C-Form {1},Vă rugăm să eliminați acest factură {0} de la 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,Vă rugăm să selectați reporta dacă doriți și să includă echilibrul de anul precedent fiscal lasă în acest an fiscal
 DocType: GL Entry,Against Voucher Type,Comparativ tipului de voucher
 DocType: Item,Attributes,Atribute
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +621,Get Items,Obtine Articole
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +211,Please enter Write Off Account,Va rugam sa introduceti Scrie Off cont
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +672,Get Items,Obtine Articole
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +219,Please enter Write Off Account,Va rugam sa introduceti Scrie Off cont
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Ultima comandă Data
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Contul {0} nu aparține companiei {1}
 DocType: Student,Guardian Details,Detalii tutore
@@ -3188,18 +3400,20 @@
 DocType: Project,Expected End Date,Data de Incheiere Preconizata
 DocType: Budget Account,Budget Amount,Buget Sumă
 DocType: Appraisal Template,Appraisal Template Title,Titlu model expertivă
+apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +37,From Date {0} for Employee {1} cannot be before employee's joining Date {2},De la data {0} pentru angajat {1} nu poate fi înainte de data aderării angajatului {2}
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +107,Commercial,Comercial
 DocType: Payment Entry,Account Paid To,Contul Plătite
 apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,Postul părinte {0} nu trebuie să fie un articol stoc
 apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Toate produsele sau serviciile.
 DocType: Expense Claim,More Details,Mai multe detalii
 DocType: Supplier Quotation,Supplier Address,Furnizor Adresa
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} buget pentru contul {1} împotriva {2} {3} este {4}. Acesta va depăși de {5}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +657,Row {0}# Account must be of type 'Fixed Asset',Rândul {0} # cont trebuie să fie de tip &quot;Activ fix&quot;
+apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} buget pentru contul {1} fata de {2} {3} este {4}. Acesta este depasit  de {5}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +665,Row {0}# Account must be of type 'Fixed Asset',Rândul {0} # cont trebuie să fie de tip &quot;Activ fix&quot;
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Out Qty,Out Cantitate
 apps/erpnext/erpnext/config/accounts.py +278,Rules to calculate shipping amount for a sale,Reguli pentru a calcula suma de transport maritim pentru o vânzare
 apps/erpnext/erpnext/selling/doctype/customer/customer.py +51,Series is mandatory,Seria este obligatorie
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +28,Financial Services,Servicii financiare
+DocType: Student Sibling,Student ID,Carnet de student
 apps/erpnext/erpnext/config/projects.py +40,Types of activities for Time Logs,Tipuri de activități pentru busteni Timp
 DocType: Tax Rule,Sales,Vânzări
 DocType: Stock Entry Detail,Basic Amount,Suma de bază
@@ -3209,11 +3423,11 @@
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +154,Cr,Cr
 DocType: Tax Rule,Billing State,Stat de facturare
 apps/erpnext/erpnext/accounts/doctype/asset/asset.js +287,Transfer,Transfer
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +197,{0} {1} does not associated with Party Account {2},{0} {1} nu asociat cu contul Party {2}
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +812,Fetch exploded BOM (including sub-assemblies),Obtine FDM expandat (inclusiv subansamblurile)
+apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +197,{0} {1} does not associated with Party Account {2},{0} {1} nu este asociat cu contul Party {2}
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +863,Fetch exploded BOM (including sub-assemblies),Obtine FDM expandat (inclusiv subansamblurile)
 DocType: Authorization Rule,Applicable To (Employee),Aplicabil pentru (angajat)
 apps/erpnext/erpnext/controllers/accounts_controller.py +123,Due Date is mandatory,Due Date este obligatorie
-apps/erpnext/erpnext/controllers/item_variant.py +57,Increment for Attribute {0} cannot be 0,Creștere pentru Atribut {0} nu poate fi 0
+apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Creștere pentru Atribut {0} nu poate fi 0
 DocType: Journal Entry,Pay To / Recd From,Pentru a plăti / Recd de la
 DocType: Naming Series,Setup Series,Seria de configurare
 DocType: Payment Reconciliation,To Invoice Date,Pentru a facturii Data
@@ -3227,27 +3441,32 @@
 DocType: Cheque Print Template,Message to show,Mesaj pentru a arăta
 DocType: Company,Retail,Cu amănuntul
 DocType: Attendance,Absent,Absent
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +564,Product Bundle,Bundle produs
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +554,Product Bundle,Bundle produs
+DocType: Purchase Invoice Item,Is Sample Item,Este Articol Exemplu
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +200,Row {0}: Invalid reference {1},Rândul {0}: referință invalid {1}
 DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Achiziționa impozite și taxe Template
 DocType: Upload Attendance,Download Template,Descărcați Sablon
 DocType: Timesheet,TS-,TS-
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +62,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: fie valoarea creditului de debit sau este necesară pentru {2}
+apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +62,{0} {1}: Either debit or credit amount is required for {2},{0} {1}: fie valoarea creditului de debit sau creditul  sunt necesare pentru {2}
 DocType: GL Entry,Remarks,Remarci
 DocType: Payment Entry,Account Paid From,Contul plătit De la
 DocType: Purchase Order Item Supplied,Raw Material Item Code,Material brut Articol Cod
 DocType: Journal Entry,Write Off Based On,Scrie Off bazat pe
+apps/erpnext/erpnext/utilities/activation.py +66,Make Lead,Asigurați-vă de plumb
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Print and Stationery,Imprimare și articole de papetărie
 DocType: Stock Settings,Show Barcode Field,Afișează coduri de bare Câmp
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +710,Send Supplier Emails,Trimite email-uri Furnizor
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +762,Send Supplier Emails,Trimite email-uri Furnizor
 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.","Salariu au fost deja procesate pentru perioada între {0} și {1}, Lăsați perioada de aplicare nu poate fi între acest interval de date."
 apps/erpnext/erpnext/config/stock.py +127,Installation record for a Serial No.,Înregistrare de instalare pentru un nr de serie
 DocType: Guardian Interest,Guardian Interest,Interes tutore
-apps/erpnext/erpnext/config/hr.py +158,Training,Pregătire
+apps/erpnext/erpnext/config/hr.py +177,Training,Pregătire
 DocType: Timesheet,Employee Detail,Detaliu angajat
-apps/erpnext/erpnext/controllers/recurring_document.py +187,Next Date's day and Repeat on Day of Month must be equal,În ziua următoare Data și repetă în ziua de luni trebuie să fie egală
+apps/erpnext/erpnext/controllers/recurring_document.py +190,Next Date's day and Repeat on Day of Month must be equal,În ziua următoare Data și repetă în ziua de luni trebuie să fie egală
 apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Setările pentru pagina de start site-ul web
 DocType: Offer Letter,Awaiting Response,Se aşteaptă răspuns
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +58,Above,Sus
-apps/erpnext/erpnext/controllers/item_variant.py +179,Invalid attribute {0} {1},atribut nevalid {0} {1}
+apps/erpnext/erpnext/controllers/item_variant.py +216,Invalid attribute {0} {1},atribut nevalid {0} {1}
+apps/erpnext/erpnext/schools/doctype/assessment_plan/assessment_plan.py +13,Please select Student Group or Student Batch,Vă rugăm să selectați Grupul Student sau Lot Student
 DocType: Salary Slip,Earning & Deduction,Câștig Salarial si Deducere
 apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +36,Optional. This setting will be used to filter in various transactions.,Opțional. Această setare va fi utilizat pentru a filtra în diverse tranzacții.
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +108,Negative Valuation Rate is not allowed,Negativ Rata de evaluare nu este permis
@@ -3263,9 +3482,10 @@
 DocType: Production Order Item,Production Order Item,Producția comandă Postul
 apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +16,No record found,Nu s-au găsit înregistrări
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +137,Cost of Scrapped Asset,Costul de active scoase din uz
+apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially ordred,parţial de comandat
 apps/erpnext/erpnext/controllers/stock_controller.py +225,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: 아이템 {2} 는 Cost Center가  필수임
 DocType: Vehicle,Policy No,Politica nr
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +603,Get Items from Product Bundle,Obține elemente din Bundle produse
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +654,Get Items from Product Bundle,Obține elemente din Bundle produse
 DocType: Asset,Straight Line,Linie dreapta
 DocType: Project User,Project User,utilizator proiect
 DocType: GL Entry,Is Advance,Este Advance
@@ -3277,11 +3497,13 @@
 DocType: Program Enrollment Tool,Get Students From,Elevii de la a lua
 DocType: Hub Settings,Seller Country,Vânzător Țară
 apps/erpnext/erpnext/config/learn.py +273,Publish Items on Website,Publica Articole pe site-ul
+apps/erpnext/erpnext/utilities/activation.py +127,Group your students in batches,Grupa elevii în loturi
 DocType: Authorization Rule,Authorization Rule,Regulă de autorizare
 DocType: Sales Invoice,Terms and Conditions Details,Termeni și condiții Detalii
 apps/erpnext/erpnext/templates/generators/item.html +85,Specifications,Specificaţii:
 DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Impozite vânzări și șabloane Taxe
 apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +59,Total (Credit),Total (Credit)
+DocType: Repayment Schedule,Payment Date,Data de plată
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +10,Apparel & Accessories,Îmbrăcăminte și accesorii
 apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Numărul de comandă
 DocType: Item Group,HTML / Banner that will show on the top of product list.,"HTML / Banner, care va arăta pe partea de sus a listei de produse."
@@ -3298,7 +3520,9 @@
 DocType: Purchase Order Item,Expected Delivery Date,Data de Livrare Preconizata
 apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Debit și credit nu este egal pentru {0} # {1}. Diferența este {2}.
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +96,Entertainment Expenses,Cheltuieli de Divertisment
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +192,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Factură de vânzări {0} trebuie anulată înainte de a anula această comandă de vânzări
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +47,Make Material Request,Asigurați-vă Material Cerere
+apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +19,Open Item {0},Deschis Postul {0}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +205,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Factură de vânzări {0} trebuie anulată înainte de a anula această comandă de vânzări
 apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +60,Age,Vârstă
 DocType: Sales Invoice Timesheet,Billing Amount,Suma de facturare
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Cantitate nevalidă specificată pentru element {0}. Cantitatea ar trebui să fie mai mare decât 0.
@@ -3315,7 +3539,7 @@
 DocType: Email Digest,Open Notifications,Notificări deschise
 DocType: Payment Entry,Difference Amount (Company Currency),Diferența Sumă (Companie Moneda)
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +77,Direct Expenses,Cheltuieli Directe
-apps/erpnext/erpnext/controllers/recurring_document.py +210,"{0} is an invalid email address in 'Notification \
+apps/erpnext/erpnext/controllers/recurring_document.py +213,"{0} is an invalid email address in 'Notification \
 						Email Address'",{0} este o adresă de e-mail nevalidă în &quot;Adresa de e-mail de notificare \ &#39;
 apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Noi surse de venit pentru clienți
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Travel Expenses,Cheltuieli de călătorie
@@ -3324,13 +3548,14 @@
 DocType: Bank Reconciliation Detail,Cheque Date,Data Cec
 apps/erpnext/erpnext/accounts/doctype/account/account.py +55,Account {0}: Parent account {1} does not belong to company: {2},Contul {0}: cont Părinte {1} nu apartine companiei: {2}
 DocType: Program Enrollment Tool,Student Applicants,Student Solicitanții
-apps/erpnext/erpnext/setup/doctype/company/company.js +60,Successfully deleted all transactions related to this company!,Șters cu succes toate tranzacțiile legate de aceasta companie!
+apps/erpnext/erpnext/setup/doctype/company/company.js +61,Successfully deleted all transactions related to this company!,Șters cu succes toate tranzacțiile legate de aceasta companie!
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Ca pe data
 DocType: Appraisal,HR,HR
 DocType: Program Enrollment,Enrollment Date,Data de inscriere
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +62,Probation,Probă
 apps/erpnext/erpnext/config/hr.py +115,Salary Components,Componente salariale
 DocType: Program Enrollment Tool,New Academic Year,Anul universitar nou
+apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +769,Return / Credit Note,Revenire / credit Notă
 DocType: Stock Settings,Auto insert Price List rate if missing,"Inserați Auto rata Lista de prețuri, dacă lipsește"
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Paid Amount,Total Suma plătită
 DocType: Production Order Item,Transferred Qty,Transferat Cantitate
@@ -3344,6 +3569,7 @@
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +235,Quantity should be greater than 0,Cantitatea trebuie sa fie mai mare decât 0
 DocType: Journal Entry,Cash Entry,Cash intrare
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,noduri pentru copii pot fi create numai în noduri de tip &quot;grup&quot;
+DocType: Leave Application,Half Day Date,Jumatate de zi Data
 DocType: Academic Year,Academic Year Name,Nume Anul universitar
 DocType: Sales Partner,Contact Desc,Persoana de Contact Desc
 apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Tip de frunze, cum ar fi casual, bolnavi, etc"
@@ -3352,9 +3578,10 @@
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +243,Please set default account in Expense Claim Type {0},Vă rugăm să setați contul implicit în cheltuielile de revendicare Tip {0}
 DocType: Assessment Result,Student Name,Numele studentului
 DocType: Brand,Item Manager,Postul de manager
+apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +141,Payroll Payable,Salarizare plateste
 DocType: Buying Settings,Default Supplier Type,Tip Furnizor Implicit
 DocType: Production Order,Total Operating Cost,Cost total de operare
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +150,Note: Item {0} entered multiple times,Notă: Articolul {0} a intrat de mai multe ori
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +152,Note: Item {0} entered multiple times,Notă: Articolul {0} a intrat de mai multe ori
 apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Toate contactele.
 apps/erpnext/erpnext/public/js/setup_wizard.js +45,Company Abbreviation,Abreviere Companie
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +136,User {0} does not exist,Utilizatorul {0} nu există
@@ -3396,7 +3623,7 @@
 DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Detaliu Taxa Avizata Articol
 apps/erpnext/erpnext/public/js/setup_wizard.js +45,Institute Abbreviation,Institutul Abreviere
 ,Item-wise Price List Rate,Rata Lista de Pret Articol-Avizat
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +841,Supplier Quotation,Furnizor ofertă
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +892,Supplier Quotation,Furnizor ofertă
 DocType: Quotation,In Words will be visible once you save the Quotation.,În cuvinte va fi vizibil după ce salvați citat.
 apps/erpnext/erpnext/schools/doctype/fees/fees.js +26,Collect Fees,Colectarea taxelor
 DocType: Attendance,ATT-,ATT-
@@ -3427,7 +3654,7 @@
 DocType: Serial No,Out of Warranty,Ieșit din garanție
 DocType: BOM Replace Tool,Replace,Înlocuirea
 DocType: Production Order,Unstopped,destupate
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +353,{0} against Sales Invoice {1},{0} comparativ cu factura de vânzări {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,{0} against Sales Invoice {1},{0} comparativ cu factura de vânzări {1}
 DocType: Sales Invoice,SINV-,SINV-
 DocType: Request for Quotation Item,Project Name,Denumirea proiectului
 DocType: Supplier,Mention if non-standard receivable account,Mentionati daca non-standard cont de primit
@@ -3439,7 +3666,7 @@
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +36,Tax Assets,Active fiscale
 DocType: BOM Item,BOM No,Nr. BOM
 DocType: Instructor,INS/,INS /
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +153,Journal Entry {0} does not have account {1} or already matched against other voucher,Jurnal de intrare {0} nu are cont {1} sau deja comparate cu alte voucher
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,Journal Entry {0} does not have account {1} or already matched against other voucher,Jurnal de intrare {0} nu are cont {1} sau deja comparate cu alte voucher
 DocType: Item,Moving Average,Mutarea medie
 DocType: BOM Replace Tool,The BOM which will be replaced,BOM care va fi înlocuit
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Electronic Equipments,Echipamente electronice
@@ -3457,7 +3684,7 @@
 DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Permiteţi următorilor utilizatori să aprobe cereri de concediu pentru zile blocate.
 apps/erpnext/erpnext/config/hr.py +132,Types of Expense Claim.,Tipuri de cheltuieli de revendicare.
 DocType: Item,Taxes,Impozite
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +301,Paid and Not Delivered,Plătite și nu sunt livrate
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +314,Paid and Not Delivered,Plătite și nu sunt livrate
 DocType: Project,Default Cost Center,Cost Center Implicit
 DocType: Purchase Invoice,End Date,Dată finalizare
 apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Tranzacții de stoc
@@ -3465,15 +3692,18 @@
 DocType: Employee,Internal Work History,Istoria interne de lucru
 DocType: Depreciation Schedule,Accumulated Depreciation Amount,Sumă Amortizarea cumulată
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +42,Private Equity,Private Equity
+DocType: Employee Loan,Fully Disbursed,deblocată în întregime
 DocType: Maintenance Visit,Customer Feedback,Feedback Client
 DocType: Account,Expense,Cheltuială
+apps/erpnext/erpnext/schools/doctype/assessment_result/assessment_result.js +34,Score cannot be greater than Maximum Score,Scorul nu poate fi mai mare decât scorul maxim
 DocType: Item Attribute,From Range,Din gama
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +91,Syntax error in formula or condition: {0},Eroare de sintaxă în formulă sau stare: {0}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +94,Syntax error in formula or condition: {0},Eroare de sintaxă în formulă sau stare: {0}
 DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,De zi cu zi de lucru Companie Rezumat Setări
 apps/erpnext/erpnext/stock/utils.py +100,Item {0} ignored since it is not a stock item,"Element {0} ignorat, deoarece nu este un element de stoc"
 DocType: Appraisal,APRSL,APRSL
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +34,Submit this Production Order for further processing.,Trimiteți acest comandă de producție pentru prelucrarea ulterioară.
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +40,Submit this Production Order for further processing.,Trimiteți acest comandă de producție pentru prelucrarea ulterioară.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +21,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","De a nu aplica regula Preturi într-o anumită tranzacție, ar trebui să fie dezactivat toate regulile de tarifare aplicabile."
+DocType: Assessment Group,Parent Assessment Group,Grup părinte de evaluare
 apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Locuri de munca
 ,Sales Order Trends,Vânzări Ordine Tendințe
 DocType: Employee,Held On,Organizat In
@@ -3483,16 +3713,18 @@
 DocType: Stock Entry Detail,Additional Cost,Cost aditional
 apps/erpnext/erpnext/public/js/setup_wizard.js +62,Financial Year End Date,Data de Incheiere An Financiar
 apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +39,"Can not filter based on Voucher No, if grouped by Voucher","Nu se poate filtra pe baza voucher Nr., în cazul gruparii in functie de Voucher"
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +731,Make Supplier Quotation,Realizeaza Ofertă Furnizor
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +784,Make Supplier Quotation,Realizeaza Ofertă Furnizor
 DocType: Quality Inspection,Incoming,Primite
 DocType: BOM,Materials Required (Exploded),Materiale necesare (explodat)
 apps/erpnext/erpnext/public/js/setup_wizard.js +190,"Add users to your organization, other than yourself","Adăugați utilizatori la organizația dvs., altele decât tine"
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +62,Posting Date cannot be future date,Dată postare nu poate fi data viitoare
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +63,Posting Date cannot be future date,Dată postare nu poate fi data viitoare
+apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No {1} does not match with {2} {3},Row # {0}: Serial No {1} nu se potrivește cu {2} {3}
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +48,Casual Leave,Concediu Aleator
 DocType: Batch,Batch ID,ID-ul lotului
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +373,Note: {0},Notă: {0}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +368,Note: {0},Notă: {0}
 ,Delivery Note Trends,Tendințe Nota de Livrare
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,This Week's Summary,Rezumat această săptămână
+,In Stock Qty,În stoc Cantitate
 apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Contul: {0} poate fi actualizat doar prin Tranzacții stoc
 DocType: Student Group Creation Tool,Get Courses,Cursuri de a lua
 DocType: GL Entry,Party,Grup
@@ -3502,31 +3734,38 @@
 DocType: Request for Quotation Item,Request for Quotation Item,Cerere de ofertă Postul
 DocType: Purchase Order,To Bill,Pentru a Bill
 DocType: Material Request,% Ordered,% Comandat
+DocType: Purchase Invoice,"Enter Email Address separated by commas, invoice will be mailed automatically on particular date","Introdu adresa de e-mail separate prin virgule, factura va fi trimis prin poștă în mod automat la anumită dată"
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +65,Piecework,Muncă în acord
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Rată de cumparare medie
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Avg. Buying Rate,Rată de cumparare medie
 DocType: Task,Actual Time (in Hours),Timpul efectiv (în ore)
 DocType: Employee,History In Company,Istoric In Companie
 apps/erpnext/erpnext/config/learn.py +107,Newsletters,Buletine
 DocType: Stock Ledger Entry,Stock Ledger Entry,Stoc Ledger intrare
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +87,Same item has been entered multiple times,Același articol a fost introdus de mai multe ori
 DocType: Department,Leave Block List,Lista Concedii Blocate
-DocType: Customer,Tax ID,ID impozit
+DocType: Sales Invoice,Tax ID,ID impozit
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +188,Item {0} is not setup for Serial Nos. Column must be blank,Articolul {0} nu este configurat pentru Numerotare Seriala. Coloana trebuie să fie vida
 DocType: Accounts Settings,Accounts Settings,Setări Conturi
 apps/erpnext/erpnext/schools/doctype/student_applicant/student_applicant.js +7,Approve,Aproba
 DocType: Customer,Sales Partner and Commission,Partener de vânzări și a Comisiei
+DocType: Employee Loan,Rate of Interest (%) / Year,Rata dobânzii (%) / An
 ,Project Quantity,proiectul Cantitatea
+apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +72,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Total {0} pentru toate articolele este zero, poate fi ar trebui să schimbați „Distribuirea cheltuielilor pe baza“"
 DocType: Opportunity,To Discuss,Pentru a discuta
 apps/erpnext/erpnext/stock/stock_ledger.py +365,{0} units of {1} needed in {2} to complete this transaction.,{0} unități de {1} necesare în {2} pentru a finaliza această tranzacție.
+DocType: Loan Type,Rate of Interest (%) Yearly,Rata dobânzii (%) anual
 DocType: SMS Settings,SMS Settings,Setări SMS
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +69,Temporary Accounts,Conturi temporare
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +169,Black,Negru
 DocType: BOM Explosion Item,BOM Explosion Item,Explozie articol BOM
 DocType: Account,Auditor,Auditor
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +56,{0} items produced,{0} articole produse
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +62,{0} items produced,{0} articole produse
 DocType: Cheque Print Template,Distance from top edge,Distanța de la marginea de sus
+apps/erpnext/erpnext/stock/get_item_details.py +272,Price List {0} is disabled or does not exist,Listă de prețuri {0} este dezactivat sau nu există
 DocType: Purchase Invoice,Return,Întoarcere
 DocType: Production Order Operation,Production Order Operation,Producția Comanda Funcționare
 DocType: Pricing Rule,Disable,Dezactivati
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +153,Mode of payment is required to make a payment,Modul de plată este necesară pentru a efectua o plată
 DocType: Project Task,Pending Review,Revizuirea în curs
 apps/erpnext/erpnext/accounts/doctype/asset/depreciation.py +106,"Asset {0} cannot be scrapped, as it is already {1}","Activ {0} nu poate fi scoase din uz, deoarece este deja {1}"
 DocType: Task,Total Expense Claim (via Expense Claim),Revendicarea Total cheltuieli (prin cheltuieli revendicarea)
@@ -3537,10 +3776,11 @@
 apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +530,Sales Order {0} is not submitted,Comandă de vânzări {0} nu este prezentat
 DocType: Homepage,Tag Line,Eticheta linie
 DocType: Fee Component,Fee Component,Taxa de Component
-apps/erpnext/erpnext/config/hr.py +176,Fleet Management,Conducerea flotei
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +839,Add items from,Adauga articole din
+apps/erpnext/erpnext/config/hr.py +195,Fleet Management,Conducerea flotei
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +890,Add items from,Adauga articole din
 apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +101,Warehouse {0}: Parent account {1} does not bolong to the company {2},Depozit {0}: contul părinte {1} nu apartine  companiei {2}
 DocType: Cheque Print Template,Regular,Regulat
+apps/erpnext/erpnext/schools/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Weightage totală a tuturor criteriilor de evaluare trebuie să fie 100%
 DocType: BOM,Last Purchase Rate,Ultima Rate de Cumparare
 DocType: Account,Asset,Valoare
 DocType: Project Task,Task ID,Sarcina ID
@@ -3551,30 +3791,36 @@
 apps/erpnext/erpnext/hub_node/page/hub/register_in_hub.html +2,Register For ERPNext Hub,Inregistreaza-te pentru ERPNext Hub
 DocType: Monthly Distribution,Monthly Distribution Percentages,Procente de distribuție lunare
 apps/erpnext/erpnext/stock/doctype/batch/batch.py +16,The selected item cannot have Batch,Elementul selectat nu poate avea Lot
-DocType: Delivery Note,% of materials delivered against this Delivery Note,% 재료가 이 배송 노트를 위해 입고됨
+apps/erpnext/erpnext/stock/stock_ledger.py +447,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a sample item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Rata de evaluare nu a fost găsit pentru elementul {0}, care trebuie să facă înregistrări contabile pentru {1} {2}. În cazul în care elementul este ca un element transacting probă în {1}, vă rugăm să menționați că în {1} tabel element. În caz contrar, vă rugăm să creați o tranzacție stoc de intrare pentru element sau menționează rata de evaluare în înregistrarea element și apoi încercați submiting / anulare această intrare"
+DocType: Delivery Note,% of materials delivered against this Delivery Note,% de materiale livrate versus notele livrarii
 DocType: Project,Customer Details,Detalii Client
 DocType: Employee,Reports to,Rapoarte
+,Unpaid Expense Claim,Revendicarea de cheltuieli neplătit
 DocType: SMS Settings,Enter url parameter for receiver nos,Introduceți parametru url pentru receptor nos
 DocType: Payment Entry,Paid Amount,Suma plătită
 DocType: Assessment Plan,Supervisor,supraveghetor
-apps/erpnext/erpnext/accounts/page/pos/pos.js +690,Online,Pe net
+apps/erpnext/erpnext/accounts/page/pos/pos.js +692,Online,Pe net
 ,Available Stock for Packing Items,Stoc disponibil pentru articole destinate împachetării
 DocType: Item Variant,Item Variant,Postul Varianta
+DocType: Assessment Result Tool,Assessment Result Tool,Instrumentul de evaluare Rezultat
 DocType: BOM Scrap Item,BOM Scrap Item,BOM Resturi Postul
+apps/erpnext/erpnext/accounts/page/pos/pos.js +845,Submitted orders can not be deleted,comenzile trimise nu pot fi șterse
 apps/erpnext/erpnext/accounts/doctype/account/account.py +118,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Soldul contului este deja în credit, nu vă este permis să setați ""Balanța trebuie să fie"" drept ""Credit""."
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +80,Quality Management,Managementul calității
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +40,Item {0} has been disabled,Postul {0} a fost dezactivat
+DocType: Employee Loan,Repay Fixed Amount per Period,Rambursa Suma fixă pentru fiecare perioadă
 apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +47,Please enter quantity for Item {0},Va rugam sa introduceti cantitatea pentru postul {0}
 DocType: Employee External Work History,Employee External Work History,Istoric Extern Locuri de Munca Angajat
 DocType: Tax Rule,Purchase,Cumpărarea
 apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Balance Qty,Cantitate de bilanţ
+apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Obiectivele nu poate fi gol
 DocType: Item Group,Parent Item Group,Părinte Grupa de articole
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} pentru {1}
 apps/erpnext/erpnext/setup/doctype/company/company.js +20,Cost Centers,Centre de cost
 DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Rata la care moneda furnizorului este convertit în moneda de bază a companiei
 apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Rând # {0}: conflicte timpilor cu rândul {1}
 DocType: Training Event Employee,Invited,invitați
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +166,Multiple active Salary Structures found for employee {0} for the given dates,"Mai multe structuri salariale active, găsite pentru angajat al {0} pentru datele indicate"
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +172,Multiple active Salary Structures found for employee {0} for the given dates,"Mai multe structuri salariale active, găsite pentru angajat al {0} pentru datele indicate"
 DocType: Opportunity,Next Contact,Următor Contact
 apps/erpnext/erpnext/config/accounts.py +272,Setup Gateway accounts.,Setup conturi Gateway.
 DocType: Employee,Employment Type,Tip angajare
@@ -3583,17 +3829,17 @@
 ,Cash Flow,Fluxul de numerar
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +92,Application period cannot be across two alocation records,Perioada de aplicare nu poate fi peste două înregistrări alocation
 DocType: Item Group,Default Expense Account,Cont de Cheltuieli Implicit
-apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +26,Student Batch or Course Schedule is mandatory,Lot de student sau un curs Program este obligatoriu
+apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +27,Student Batch or Course Schedule is mandatory,Lot de student sau un curs Program este obligatoriu
 DocType: Employee,Notice (days),Preaviz (zile)
 DocType: Tax Rule,Sales Tax Template,Format impozitul pe vânzări
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1902,Select items to save the invoice,Selectați elemente pentru a salva factura
+apps/erpnext/erpnext/accounts/page/pos/pos.js +2298,Select items to save the invoice,Selectați elemente pentru a salva factura
 DocType: Employee,Encashment Date,Data plata in Numerar
 DocType: Training Event,Internet,Internet
 DocType: Account,Stock Adjustment,Ajustarea stoc
 apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Există implicit Activitate Cost de activitate de tip - {0}
 DocType: Production Order,Planned Operating Cost,Planificate cost de operare
 DocType: Academic Term,Term Start Date,Termenul Data de începere
-apps/erpnext/erpnext/controllers/recurring_document.py +133,Please find attached {0} #{1},Vă rugăm să găsiți atașat {0} # {1}
+apps/erpnext/erpnext/controllers/recurring_document.py +136,Please find attached {0} #{1},Vă rugăm să găsiți atașat {0} # {1}
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Banca echilibru Declarație pe General Ledger
 DocType: Job Applicant,Applicant Name,Nume solicitant
 DocType: Authorization Rule,Customer / Item Name,Client / Denumire articol
@@ -3610,12 +3856,13 @@
 DocType: Serial No,Under AMC,Sub AMC
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +54,Item valuation rate is recalculated considering landed cost voucher amount,Rata de evaluare Articolul este recalculat în vedere aterizat sumă voucher de cost
 apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Setări implicite pentru tranzacțiile de vânzare.
+DocType: Guardian,Guardian Of ,Guardian Of
+DocType: Grading Scale Interval,Threshold,Prag
 DocType: BOM Replace Tool,Current BOM,FDM curent
 apps/erpnext/erpnext/public/js/utils.js +39,Add Serial No,Adăugaţi Nr. de Serie
 apps/erpnext/erpnext/config/support.py +22,Warranty,garanţie
 DocType: Purchase Invoice,Debit Note Issued,Debit Notă Eliberat
 DocType: Production Order,Warehouses,Depozite
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Print and Stationary,Imprimare și staționare
 apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} activul nu poate fi transferat
 DocType: Workstation,per hour,pe oră
 apps/erpnext/erpnext/config/buying.py +7,Purchasing,cumpărare
@@ -3630,18 +3877,21 @@
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +71,Max discount allowed for item: {0} is {1}%,Discount maxim permis pentru articol: {0} este {1}%
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +173,Net Asset value as on,Valoarea activelor nete pe
 DocType: Account,Receivable,De încasat
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +265,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Nu este permis să schimbe furnizorul ca Comandă există deja
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +278,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Row # {0}: Nu este permis să schimbe furnizorul ca Comandă există deja
 DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Rol care i se permite să prezinte tranzacțiile care depășesc limitele de credit stabilite.
-apps/erpnext/erpnext/accounts/page/pos/pos.js +842,"Master data syncing, it might take some time","datele de bază de sincronizare, ar putea dura ceva timp"
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +904,Select Items to Manufacture,Selectați elementele de Fabricare
+apps/erpnext/erpnext/accounts/page/pos/pos.js +909,"Master data syncing, it might take some time","datele de bază de sincronizare, ar putea dura ceva timp"
 DocType: Item,Material Issue,Problema de material
 DocType: Hub Settings,Seller Description,Descriere vânzător
 DocType: Employee Education,Qualification,Calificare
 DocType: Item Price,Item Price,Pret Articol
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +48,Soap & Detergent,Soap & Detergent
+DocType: BOM,Show Items,Afișare articole
 apps/erpnext/erpnext/schools/doctype/course_schedule/course_schedule.py +39,From Time cannot be greater than To Time.,Din Timpul nu poate fi mai mare decât în timp.
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +36,Motion Picture & Video,Motion Picture & Video
 apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Ordonat
 DocType: Salary Detail,Component,component
+DocType: Assessment Criteria,Assessment Criteria Group,Criterii de evaluare de grup
 apps/erpnext/erpnext/accounts/doctype/asset/asset.py +71,Opening Accumulated Depreciation must be less than equal to {0},Amortizarea de deschidere trebuie să fie mai mică Acumulate decât egală cu {0}
 DocType: Warehouse,Warehouse Name,Denumire depozit
 DocType: Naming Series,Select Transaction,Selectați Transaction
@@ -3651,11 +3901,13 @@
 apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Analtyics Suport
 apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +141,Uncheck all,Deselecteaza tot
 apps/erpnext/erpnext/accounts/doctype/accounts_settings/accounts_settings.py +27,Company is missing in warehouses {0},Compania lipsește din depozitul {0}
+apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +40,Student {0}: {1} does not belong to Student Group {2},Student {0}: {1} nu face parte din Grupul Student {2}
 DocType: POS Profile,Terms and Conditions,Termeni şi condiţii
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},Pentru a Data ar trebui să fie în anul fiscal. Presupunând Pentru a Data = {0}
 DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Aici puteți stoca informatii despre inaltime, greutate, alergii, probleme medicale etc"
 DocType: Leave Block List,Applies to Company,Se aplică companiei
 apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +199,Cannot cancel because submitted Stock Entry {0} exists,"Nu pot anula, deoarece a prezentat Bursa de intrare {0} există"
+DocType: Employee Loan,Disbursement Date,debursare
 DocType: Vehicle,Vehicle,Vehicul
 DocType: Purchase Invoice,In Words,În cuvinte
 DocType: POS Profile,Item Groups,Grupuri articol
@@ -3672,10 +3924,12 @@
 DocType: Email Digest,Add/Remove Recipients,Adăugaţi/Stergeţi Destinatari
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +452,Transaction not allowed against stopped Production Order {0},Tranzacție nu este permis împotriva oprit comandă de producție {0}
 apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Pentru a seta acest an fiscal ca implicit, faceți clic pe ""Set as Default"""
-apps/erpnext/erpnext/projects/doctype/project/project.py +185,Join,A adera
+apps/erpnext/erpnext/projects/doctype/project/project.py +192,Join,A adera
 apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +20,Shortage Qty,Lipsă Cantitate
 apps/erpnext/erpnext/stock/doctype/item/item.py +666,Item variant {0} exists with same attributes,Postul varianta {0} există cu aceleași atribute
+DocType: Employee Loan,Repay from Salary,Rambursa din salariu
 DocType: Leave Application,LAP/,LAP /
+apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +334,Requesting payment against {0} {1} for amount {2},Solicitarea de plată contra {0} {1} pentru suma {2}
 DocType: Salary Slip,Salary Slip,Salariul Slip
 DocType: Lead,Lost Quotation,ofertă pierdută
 DocType: Pricing Rule,Margin Rate or Amount,Rata de marjă sau Sumă
@@ -3683,13 +3937,14 @@
 DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Generarea de ambalare slip pentru pachetele de a fi livrate. Folosit pentru a notifica numărul pachet, conținutul pachetului și greutatea sa."
 DocType: Sales Invoice Item,Sales Order Item,Comandă de vânzări Postul
 DocType: Salary Slip,Payment Days,Zile de plată
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +209,Warehouses with child nodes cannot be converted to ledger,Depozite cu noduri copil nu pot fi convertite în Cartea Mare
+apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +221,Warehouses with child nodes cannot be converted to ledger,Depozite cu noduri copil nu pot fi convertite în Cartea Mare
 DocType: BOM,Manage cost of operations,Gestioneaza costul operațiunilor
 DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Atunci când oricare dintre tranzacțiile verificate sunt ""Trimis"", un e-mail de tip pop-up a deschis în mod automat pentru a trimite un e-mail la ""Contact"", asociat în această operațiune, cu tranzacția ca un atașament. Utilizatorul poate sau nu poate trimite e-mail."
 apps/erpnext/erpnext/config/setup.py +14,Global Settings,Setări globale
+DocType: Assessment Result Detail,Assessment Result Detail,Evaluare Rezultat Detalii
 DocType: Employee Education,Employee Education,Educație Angajat
 apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,Duplicate item group found in the item group table,Grup de element dublu exemplar găsit în tabelul de grup de elemente
-apps/erpnext/erpnext/public/js/controllers/transaction.js +896,It is needed to fetch Item Details.,Este nevoie să-i aducă Detalii despre articol.
+apps/erpnext/erpnext/public/js/controllers/transaction.js +930,It is needed to fetch Item Details.,Este nevoie să-i aducă Detalii despre articol.
 DocType: Salary Slip,Net Pay,Plată netă
 DocType: Account,Account,Cont
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} has already been received,Serial Nu {0} a fost deja primit
@@ -3698,6 +3953,7 @@
 apps/erpnext/erpnext/controllers/stock_controller.py +91,"Warehouse {0} is not linked to any account, please create/link the corresponding (Asset) account for the warehouse.","Depozit {0} nu este legată de nici un cont, vă rugăm să creați / link contul corespunzător (activ) pentru depozit."
 DocType: Purchase Invoice,Recurring Id,Recurent Id
 DocType: Customer,Sales Team Details,Detalii de vânzări Echipa
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1252,Delete permanently?,Șterge definitiv?
 DocType: Expense Claim,Total Claimed Amount,Total suma pretinsă
 apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Potențiale oportunități de vânzare.
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +211,Invalid {0},Invalid {0}
@@ -3706,8 +3962,9 @@
 DocType: Delivery Note,Billing Address Name,Numele din adresa de facturare
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +22,Department Stores,Magazine Departament
 DocType: Warehouse,PIN,PIN
+apps/erpnext/erpnext/setup/setup_wizard/sample_data.py +108,Setup your School in ERPNext,Setup Școala în ERPNext
 DocType: Sales Invoice,Base Change Amount (Company Currency),De schimbare a bazei Suma (Companie Moneda)
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +310,No accounting entries for the following warehouses,Nici o intrare contabile pentru următoarele depozite
+apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +311,No accounting entries for the following warehouses,Nici o intrare contabile pentru următoarele depozite
 apps/erpnext/erpnext/projects/doctype/project/project.js +92,Save the document first.,Salvați documentul primul.
 DocType: Account,Chargeable,Taxabil/a
 DocType: Company,Change Abbreviation,Schimbarea abreviere
@@ -3721,7 +3978,7 @@
 DocType: Purchase Invoice,Raw Materials Supplied,Materii prime furnizate
 DocType: Purchase Invoice,Recurring Print Format,Recurente Print Format
 DocType: C-Form,Series,Serii
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +58,Expected Delivery Date cannot be before Purchase Order Date,Data de Livrare Preconizata nu poate fi anterioara Datei Ordinului de Cumparare
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +61,Expected Delivery Date cannot be before Purchase Order Date,Data de Livrare Preconizata nu poate fi anterioara Datei Ordinului de Cumparare
 DocType: Appraisal,Appraisal Template,Model expertiză
 DocType: Item Group,Item Classification,Postul Clasificare
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +93,Business Development Manager,Manager pentru Dezvoltarea Afacerilor
@@ -3758,13 +4015,13 @@
 apps/erpnext/erpnext/public/js/stock_analytics.js +58,Select Brand...,Selectați Marca ...
 apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +149,Accumulated Depreciation as on,Amortizarea ca pe acumulat
 DocType: Sales Invoice,C-Form Applicable,Formular-C aplicabil
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +380,Operation Time must be greater than 0 for Operation {0},Funcționarea timp trebuie să fie mai mare decât 0 pentru funcționare {0}
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +398,Operation Time must be greater than 0 for Operation {0},Funcționarea timp trebuie să fie mai mare decât 0 pentru funcționare {0}
 apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +100,Warehouse is mandatory,Warehouse este obligatorie
 DocType: Supplier,Address and Contacts,Adresa si contact
 DocType: UOM Conversion Detail,UOM Conversion Detail,Detaliu UOM de conversie
 apps/erpnext/erpnext/public/js/setup_wizard.js +172,Keep it web friendly 900px (w) by 100px (h),Păstrați-l in parametrii web amiabili si anume 900px (w) pe 100px (h)
 DocType: Program,Program Abbreviation,Abreviere de program
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +368,Production Order cannot be raised against a Item Template,Producția Comanda nu poate fi ridicată pe un șablon Postul
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +386,Production Order cannot be raised against a Item Template,Producția Comanda nu poate fi ridicată pe un șablon Postul
 apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +51,Charges are updated in Purchase Receipt against each item,Tarifele sunt actualizate în Primirea cumparare pentru fiecare articol
 DocType: Warranty Claim,Resolved By,Rezolvat prin
 DocType: Appraisal,Start Date,Data începerii
@@ -3772,6 +4029,7 @@
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Cecuri și Depozite respingă incorect
 apps/erpnext/erpnext/accounts/doctype/account/account.py +51,Account {0}: You can not assign itself as parent account,Contul {0}: nu puteți atribui contului în sine calitatea de cont părinte
 DocType: Purchase Invoice Item,Price List Rate,Lista de prețuri Rate
+apps/erpnext/erpnext/utilities/activation.py +73,Create customer quotes,Creați citate client
 DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Arata ""Pe stoc"" sau ""nu este pe stoc"", bazat pe stoc disponibil în acest depozit."
 apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Factură de materiale (BOM)
 DocType: Item,Average time taken by the supplier to deliver,Timpul mediu luate de către furnizor de a livra
@@ -3806,6 +4064,7 @@
 DocType: Cheque Print Template,Cheque Print Template,Format Print cecului
 apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Grafic Centre de Cost
 ,Requested Items To Be Ordered,Elemente solicitate să fie comandate
+apps/erpnext/erpnext/accounts/doctype/account/account.py +181,Warehouse company must be same as Account company,Depozit de companie trebuie să fie aceeași ca și companie de cont
 DocType: Price List,Price List Name,Lista de prețuri Nume
 apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +31,Daily Work Summary for {0},Sumar zilnic de lucru pentru {0}
 DocType: Employee Loan,Totals,Totaluri
@@ -3813,9 +4072,10 @@
 ,Ordered Items To Be Delivered,Comandat de elemente pentru a fi livrate
 DocType: Account,Income,Venit
 DocType: Industry Type,Industry Type,Industrie Tip
-apps/erpnext/erpnext/templates/includes/cart.js +141,Something went wrong!,Ceva a mers prost!
+apps/erpnext/erpnext/templates/includes/cart.js +149,Something went wrong!,Ceva a mers prost!
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +124,Warning: Leave application contains following block dates,Atenție: Lăsați aplicație conține următoarele date de bloc
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +245,Sales Invoice {0} has already been submitted,Factură de vânzări {0} a fost deja prezentat
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +247,Sales Invoice {0} has already been submitted,Factură de vânzări {0} a fost deja prezentat
+DocType: Assessment Result Detail,Score,Scor
 apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Anul fiscal {0} nu există
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,Data Finalizare
 DocType: Purchase Invoice Item,Amount (Company Currency),Sumă (monedă companie)
@@ -3823,7 +4083,7 @@
 DocType: Fee Structure,Student Category,Categoria de student
 apps/erpnext/erpnext/schools/doctype/program_enrollment_tool/program_enrollment_tool.py +14,Mandatory feild - Get Students From,feild obligatoriu - Ia studenți de la
 DocType: Announcement,Student,Student
-apps/erpnext/erpnext/config/hr.py +212,Organization unit (department) master.,Unitate de organizare (departament) maestru.
+apps/erpnext/erpnext/config/hr.py +229,Organization unit (department) master.,Unitate de organizare (departament) maestru.
 apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +26,Please enter valid mobile nos,Va rugam sa introduceti nos mobile valabile
 apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Vă rugăm să introduceți mesajul înainte de trimitere
 DocType: Email Digest,Pending Quotations,în așteptare Cotațiile
@@ -3838,12 +4098,13 @@
 DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Mesaje mai mari de 160 de caractere vor fi împărțite în mai multe mesaje
 DocType: Purchase Receipt Item,Received and Accepted,Primite și acceptate
 ,Serial No Service Contract Expiry,Serial Nu Service Contract de expirare
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,You cannot credit and debit same account at the same time,"Nu puteți credit și de debit același cont, în același timp,"
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +287,You cannot credit and debit same account at the same time,"Nu puteți credit și de debit același cont, în același timp,"
 DocType: Naming Series,Help HTML,Ajutor HTML
 DocType: Student Group Creation Tool,Student Group Creation Tool,Instrumentul de creare a grupului de student
+DocType: Item,Variant Based On,Varianta Bazat pe
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Weightage total alocat este de 100%. Este {0}
 apps/erpnext/erpnext/public/js/setup_wizard.js +265,Your Suppliers,Furnizorii dumneavoastră
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +55,Cannot set as Lost as Sales Order is made.,Nu se poate seta pierdut deoarece se intocmeste comandă de vânzări.
+apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +56,Cannot set as Lost as Sales Order is made.,Nu se poate seta pierdut deoarece se intocmeste comandă de vânzări.
 DocType: Request for Quotation Item,Supplier Part No,Furnizor de piesa
 apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +356,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Nu se poate deduce atunci când este categoria de &quot;evaluare&quot; sau &quot;Vaulation și Total&quot;
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +336,Received From,Primit de la
@@ -3851,18 +4112,19 @@
 DocType: Item,Has Serial No,Are nr. de serie
 DocType: Employee,Date of Issue,Data Problemei
 apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +19,{0}: From {0} for {1},{0}: de la {0} pentru {1}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +153,Row #{0}: Set Supplier for item {1},Row # {0}: Set Furnizor de produs {1}
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +157,Row #{0}: Set Supplier for item {1},Row # {0}: Set Furnizor de produs {1}
 apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Hours value must be greater than zero.,Rândul {0}: Valoarea ore trebuie să fie mai mare decât zero.
 apps/erpnext/erpnext/stock/doctype/item/item.py +172,Website Image {0} attached to Item {1} cannot be found,Site-ul Image {0} atașat la postul {1} nu poate fi găsit
 DocType: Issue,Content Type,Tip Conținut
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +17,Computer,Computer
 DocType: Item,List this Item in multiple groups on the website.,Listeaza acest articol in grupuri multiple de pe site-ul.\
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +316,Please check Multi Currency option to allow accounts with other currency,Vă rugăm să verificați Multi opțiune de valuta pentru a permite conturi cu altă valută
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +311,Please check Multi Currency option to allow accounts with other currency,Vă rugăm să verificați Multi opțiune de valuta pentru a permite conturi cu altă valută
 apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +86,Item: {0} does not exist in the system,Postul: {0} nu există în sistemul
 apps/erpnext/erpnext/accounts/doctype/account/account.py +110,You are not authorized to set Frozen value,Nu esti autorizat pentru a configura valoarea Congelat
 DocType: Payment Reconciliation,Get Unreconciled Entries,Ia nereconciliate Entries
 DocType: Payment Reconciliation,From Invoice Date,De la data facturii
 apps/erpnext/erpnext/accounts/party.py +254,Billing currency must be equal to either default comapany's currency or party account currency,"monedă de facturare trebuie să fie egală cu moneda sau contul de partid valută, fie implicit comapany lui"
+apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +37,Leave Encashment,Lasă încasări
 apps/erpnext/erpnext/public/js/setup_wizard.js +48,What does it do?,Ce face?
 DocType: Delivery Note,To Warehouse,Pentru Warehouse
 apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +23,All Student Admissions,Toate Admitere Student
@@ -3870,11 +4132,13 @@
 apps/erpnext/erpnext/stock/doctype/item/item.py +410,'Has Serial No' can not be 'Yes' for non-stock item,'Are numãr de serie' nu poate fi 'Da' pentru articolele care nu au stoc
 apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +39,Attendance can not be marked for future dates,Prezenţa nu poate fi consemnată pentru date viitoare
 DocType: Pricing Rule,Pricing Rule Help,Regula de stabilire a prețurilor de ajutor
+DocType: School House,House Name,Numele casei
 DocType: Purchase Taxes and Charges,Account Head,Titularul Contului
 apps/erpnext/erpnext/config/stock.py +168,Update additional costs to calculate landed cost of items,Actualizati costuri suplimentare pentru a calcula costul aterizat de articole
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +115,Electrical,Electric
+apps/erpnext/erpnext/utilities/activation.py +101,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,"Adăugați restul organizației dvs. ca utilizatorii. Puteți adăuga, de asemenea, invita clienții să portalul prin adăugarea acestora din Contacte"
 DocType: Stock Entry,Total Value Difference (Out - In),Diferența Valoarea totală (Out - In)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +341,Row {0}: Exchange Rate is mandatory,Row {0}: Exchange Rate este obligatorie
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +336,Row {0}: Exchange Rate is mandatory,Row {0}: Exchange Rate este obligatorie
 apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},ID-ul de utilizator nu este setat pentru Angajat {0}
 DocType: Vehicle,Vehicle Value,Valoarea vehiculului
 DocType: Stock Entry,Default Source Warehouse,Depozit Sursa Implicit
@@ -3893,13 +4157,13 @@
 apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +35,Delivery Note {0} must not be submitted,Nota de Livrare {0} nu trebuie sa fie introdusa
 DocType: Notification Control,Sales Invoice Message,Factură de vânzări Mesaj
 apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Contul {0} de închidere trebuie să fie de tip răspunderii / capitaluri proprii
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +307,Salary Slip of employee {0} already created for time sheet {1},Salariu de alunecare angajat al {0} deja creat pentru foaie de timp {1}
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +320,Salary Slip of employee {0} already created for time sheet {1},Salariu de alunecare angajat al {0} deja creat pentru foaie de timp {1}
 DocType: Vehicle Log,Odometer,Contorul de kilometraj
 DocType: Sales Order Item,Ordered Qty,Ordonat Cantitate
 apps/erpnext/erpnext/stock/doctype/item/item.py +694,Item {0} is disabled,Postul {0} este dezactivat
 DocType: Stock Settings,Stock Frozen Upto,Stoc Frozen Până la
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +825,BOM does not contain any stock item,BOM nu conține nici un element de stoc
-apps/erpnext/erpnext/controllers/recurring_document.py +169,Period From and Period To dates mandatory for recurring {0},Perioada de la si perioadă la datele obligatorii pentru recurente {0}
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +876,BOM does not contain any stock item,BOM nu conține nici un element de stoc
+apps/erpnext/erpnext/controllers/recurring_document.py +172,Period From and Period To dates mandatory for recurring {0},Perioada de la si perioadă la datele obligatorii pentru recurente {0}
 apps/erpnext/erpnext/config/projects.py +18,Project activity / task.,Activitatea de proiect / sarcină.
 DocType: Vehicle Log,Refuelling Details,Detalii de realimentare
 apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Generează fluturașe de salariu
@@ -3908,7 +4172,7 @@
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +106,Last purchase rate not found,Rata Ultima achiziție nu a fost găsit
 DocType: Purchase Invoice,Write Off Amount (Company Currency),Scrie Off Suma (Compania de valuta)
 DocType: Sales Invoice Timesheet,Billing Hours,Ore de facturare
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +467,Default BOM for {0} not found,BOM implicit pentru {0} nu a fost găsit
+apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +499,Default BOM for {0} not found,BOM implicit pentru {0} nu a fost găsit
 apps/erpnext/erpnext/stock/doctype/item/item.py +490,Row #{0}: Please set reorder quantity,Row # {0}: Va rugam sa seta cantitatea reordona
 DocType: Fees,Program Enrollment,programul de înscriere
 DocType: Landed Cost Voucher,Landed Cost Voucher,Voucher Cost Landed
@@ -3934,7 +4198,7 @@
 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.","Exemplu:. ABCD ##### 
  Dacă seria este setat și nu de serie nu este menționat în tranzacții, numărul de atunci automat de serie va fi creat pe baza acestei serii. Dacă întotdeauna doriți să se menționeze explicit Serial nr de acest articol. părăsi acest gol."
 DocType: Upload Attendance,Upload Attendance,Încărcați Spectatori
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +300,BOM and Manufacturing Quantity are required,BOM și cantitatea de producție sunt necesare
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +302,BOM and Manufacturing Quantity are required,BOM și cantitatea de producție sunt necesare
 apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Clasă de uzură 2
 DocType: SG Creation Tool Course,Max Strength,Putere max
 apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +21,BOM replaced,BOM înlocuit
@@ -3942,7 +4206,8 @@
 apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +114,Available {0},Disponibile {0}
 DocType: Manufacturing Settings,Manufacturing Settings,Setări de fabricație
 apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Configurarea e-mail
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +97,Please enter default currency in Company Master,Va rugam sa introduceti moneda implicit în Compania de Master
+apps/erpnext/erpnext/schools/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +51,Guardian1 Mobile No,Guardian1 mobil nr
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +98,Please enter default currency in Company Master,Va rugam sa introduceti moneda implicit în Compania de Master
 DocType: Stock Entry Detail,Stock Entry Detail,Stoc de intrare Detaliu
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Daily Reminders,Memento de zi cu zi
 DocType: Products Settings,Home Page is Products,Pagina este Produse
@@ -3963,6 +4228,8 @@
 apps/erpnext/erpnext/config/accounts.py +252,Default settings for accounting transactions.,Setări implicite pentru tranzacțiile de contabilitate.
 DocType: Maintenance Visit,MV,MV
 apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +59,Expected Date cannot be before Material Request Date,Data Preconizata nu poate fi anterioara Datei Cererii de Materiale
+DocType: Production Order,Source Warehouse (for reserving Items),Sursa de depozit (pentru rezervarea articole)
+DocType: Employee Loan,Repayment Period in Months,Rambursarea Perioada în luni
 apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Eroare: Nu a id valid?
 DocType: Naming Series,Update Series Number,Actualizare Serii Număr
 DocType: Account,Equity,Echitate
@@ -3973,14 +4240,14 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +88,Engineer,Inginer
 DocType: Journal Entry,Total Amount Currency,Suma totală Moneda
 apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Căutare subansambluri
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +401,Item Code required at Row No {0},Cod Articol necesar la inregistrarea Nr. {0}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +164,Item Code required at Row No {0},Cod Articol necesar la inregistrarea Nr. {0}
 DocType: Sales Partner,Partner Type,Tip partener
 DocType: Purchase Taxes and Charges,Actual,Efectiv
 DocType: Authorization Rule,Customerwise Discount,Reducere Client
 apps/erpnext/erpnext/config/projects.py +35,Timesheet for tasks.,Timesheet pentru sarcini.
 DocType: Purchase Invoice,Against Expense Account,Comparativ contului de cheltuieli
 DocType: Production Order,Production Order,Număr Comandă Producţie:
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +252,Installation Note {0} has already been submitted,Instalarea Nota {0} a fost deja prezentat
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +254,Installation Note {0} has already been submitted,Instalarea Nota {0} a fost deja prezentat
 DocType: Bank Reconciliation,Get Payment Entries,Participările de plată
 DocType: Quotation Item,Against Docname,Comparativ denumirii documentului
 DocType: SMS Center,All Employee (Active),Toți angajații (activi)
@@ -4006,10 +4273,13 @@
 apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +131,Successfully Reconciled,Împăcați cu succes
 DocType: Request for Quotation Supplier,Download PDF,descarcă PDF
 DocType: Production Order,Planned End Date,Planificate Data de încheiere
+apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,"Vă rugăm să configurare serie de numerotare pentru prezență, prin intermediul Setup&gt; Numerotare Series"
 apps/erpnext/erpnext/config/stock.py +184,Where items are stored.,În cazul în care elementele sunt stocate.
 DocType: Request for Quotation,Supplier Detail,Detalii furnizor
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Error in formula or condition: {0},Eroare în formulă sau o condiție: {0}
 apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +19,Invoiced Amount,Suma facturată
 DocType: Attendance,Attendance,Prezență
+apps/erpnext/erpnext/public/js/pos/pos.html +106,Stock Items,stoc
 DocType: BOM,Materials,Materiale
 DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","In cazul in care este debifat, lista va trebui să fie adăugata fiecarui Departament unde trebuie sa fie aplicată."
 apps/erpnext/erpnext/accounts/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Sursa si Target Warehouse nu poate fi aceeași
@@ -4022,16 +4292,15 @@
 DocType: Task,Review Date,Data Comentariului
 DocType: Purchase Invoice,Advance Payments,Plățile în avans
 DocType: Purchase Taxes and Charges,On Net Total,Pe net total
-apps/erpnext/erpnext/controllers/item_variant.py +67,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Valoare pentru atributul {0} trebuie să fie în intervalul de {1} la {2} în trepte de {3} pentru postul {4}
+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},Valoare pentru atributul {0} trebuie să fie în intervalul de {1} la {2} în trepte de {3} pentru postul {4}
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +152,Target warehouse in row {0} must be same as Production Order,Depozit țintă în rândul {0} trebuie să fie același ca și de producție de comandă
-apps/erpnext/erpnext/controllers/recurring_document.py +214,'Notification Email Addresses' not specified for recurring %s,"'Adresele de email pentru notificari', nespecificate pentru factura recurenta %s"
+apps/erpnext/erpnext/controllers/recurring_document.py +217,'Notification Email Addresses' not specified for recurring %s,"'Adresele de email pentru notificari', nespecificate pentru factura recurenta %s"
 apps/erpnext/erpnext/accounts/doctype/account/account.py +128,Currency can not be changed after making entries using some other currency,Moneda nu poate fi schimbat după efectuarea înregistrări folosind un altă valută
 DocType: Vehicle Service,Clutch Plate,Placă de ambreiaj
 DocType: Company,Round Off Account,Rotunji cont
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +91,Administrative Expenses,Cheltuieli administrative
 apps/erpnext/erpnext/setup/setup_wizard/industry_type.py +18,Consulting,Consilia
 DocType: Customer Group,Parent Customer Group,Părinte Client Group
-DocType: Vehicle Service,Change,Schimbare
 DocType: Purchase Invoice,Contact Email,Email Persoana de Contact
 DocType: Appraisal Goal,Score Earned,Scor Earned
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +191,Notice Period,Perioada De Preaviz
@@ -4057,6 +4326,7 @@
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,Data de amortizare
 apps/erpnext/erpnext/controllers/buying_controller.py +80,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Taxa Categoria nu poate fi ""de evaluare"" sau ""de evaluare și total"", ca toate elementele sunt produse non-stoc"
 DocType: Issue,Support Team,Echipa de Suport
+apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Expirării (în zile)
 DocType: Appraisal,Total Score (Out of 5),Scor total (din 5)
 DocType: Fee Structure,FS.,FS.
 DocType: Batch,Batch,Lot
@@ -4064,24 +4334,27 @@
 DocType: Room,Seating Capacity,Numărul de locuri
 DocType: Issue,ISS-,ISS-
 DocType: Project,Total Expense Claim (via Expense Claims),Revendicarea Total cheltuieli (prin formularele de decont)
+DocType: Assessment Result,Total Score,Scorul total
 DocType: Journal Entry,Debit Note,Nota de Debit
 DocType: Stock Entry,As per Stock UOM,Ca şi pentru stoc UOM
 apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Nu expirat
 DocType: Student Log,Achievement,Realizare
 DocType: Journal Entry,Total Debit,Total debit
 DocType: Manufacturing Settings,Default Finished Goods Warehouse,Implicite terminat Marfuri Warehouse
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Persoana de vânzări
+apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +78,Sales Person,Persoana de vânzări
 DocType: SMS Parameter,SMS Parameter,SMS Parametru
 apps/erpnext/erpnext/config/accounts.py +197,Budget and Cost Center,Buget și centru de cost
 DocType: Vehicle Service,Half Yearly,Semestrial
 DocType: Lead,Blog Subscriber,Abonat blog
 DocType: Guardian,Alternate Number,Număr alternativ
+DocType: Assessment Plan Criteria,Maximum Score,Scor maxim
 apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Creare reguli pentru restricționare tranzacții bazate pe valori.
 DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","In cazul in care se bifeaza, nr. total de zile lucratoare va include si sarbatorile, iar acest lucru va reduce valoarea Salariul pe Zi"
 DocType: Purchase Invoice,Total Advance,Total de Advance
 apps/erpnext/erpnext/schools/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,Pe termen Data de încheiere nu poate fi mai devreme decât Start Termen Data. Vă rugăm să corectați datele și încercați din nou.
+,BOM Stock Report,BOM Raport stoc
 DocType: Stock Reconciliation Item,Quantity Difference,cantitate diferenţă
-apps/erpnext/erpnext/config/hr.py +314,Processing Payroll,Prelucrare de salarizare
+apps/erpnext/erpnext/config/hr.py +311,Processing Payroll,Prelucrare de salarizare
 DocType: Opportunity Item,Basic Rate,Rată elementară
 DocType: GL Entry,Credit Amount,Suma de credit
 DocType: Cheque Print Template,Signatory Position,Poziție semnatar
@@ -4094,11 +4367,13 @@
 DocType: Tax Rule,Tax Rule,Regula de impozitare
 DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Menține Aceeași Rată in Cursul Ciclului de Vânzări
 DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planificați busteni de timp în afara orelor de lucru de lucru.
+apps/erpnext/erpnext/public/js/pos/pos.html +89,Customers in Queue,Clienții din Coadă
 DocType: Student,Nationality,Naţionalitate
 ,Items To Be Requested,Articole care vor fi solicitate
 DocType: Purchase Order,Get Last Purchase Rate,Obtine Ultima Rate de Cumparare
 DocType: Company,Company Info,Informatii Companie
-apps/erpnext/erpnext/accounts/page/pos/pos.js +981,Select or add new customer,Selectați sau adăugați client nou
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1284,Select or add new customer,Selectați sau adăugați client nou
+apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +146,Cost center is required to book an expense claim,centru de cost este necesar pentru a rezerva o cerere de cheltuieli
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Aplicţie a fondurilor (active)
 apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Aceasta se bazează pe prezența a acestui angajat
 apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +462,Debit Account,Contul debit
@@ -4107,30 +4382,29 @@
 DocType: Sales Invoice,Rounded Total (Company Currency),Rotunjite total (Compania de valuta)
 apps/erpnext/erpnext/accounts/doctype/account/account.py +100,Cannot covert to Group because Account Type is selected.,Nu se poate sub acoperire la Grupul pentru că este selectată Tip cont.
 DocType: Purchase Common,Purchase Common,Cumpărare comună
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +218,{0} {1} has been modified. Please refresh.,{0} {1} a fost modificat. Vă rugăm să reîmprospătați.
+apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +231,{0} {1} has been modified. Please refresh.,{0} {1} a fost modificat. Vă rugăm să reîmprospătați.
 DocType: Leave Block List,Stop users from making Leave Applications on following days.,Opri utilizatorii de la a face aplicații concediu pentru următoarele zile.
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Suma cumpărată
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +209,Supplier Quotation {0} created,Furnizor de oferta {0} creat
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +215,Supplier Quotation {0} created,Furnizor de oferta {0} creat
 apps/erpnext/erpnext/accounts/report/financial_statements.py +85,End Year cannot be before Start Year,Sfârșitul anului nu poate fi înainte de Anul de început
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +184,Employee Benefits,Beneficiile angajatului
-DocType: Sales Invoice,Is POS,Este POS
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +234,Packed quantity must equal quantity for Item {0} in row {1},Cantitate ambalate trebuie să fie egală cantitate pentru postul {0} în rândul {1}
+apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +236,Packed quantity must equal quantity for Item {0} in row {1},Cantitate ambalate trebuie să fie egală cantitate pentru postul {0} în rândul {1}
 DocType: Production Order,Manufactured Qty,Produs Cantitate
 DocType: Purchase Receipt Item,Accepted Quantity,Cantitatea Acceptata
 apps/erpnext/erpnext/hr/doctype/employee/employee.py +238,Please set a default Holiday List for Employee {0} or Company {1},Vă rugăm să setați o valoare implicită Lista de vacanță pentru angajat {0} sau companie {1}
 apps/erpnext/erpnext/accounts/party.py +25,{0}: {1} does not exists,{0}: {1} nu există
 apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Facturi cu valoarea ridicată pentru clienți.
 apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,Id-ul proiectului
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +521,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Rândul nr {0}: Suma nu poate fi mai mare decât așteptarea Suma împotriva revendicării cheltuieli {1}. În așteptarea Suma este {2}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +522,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Rândul nr {0}: Suma nu poate fi mai mare decât așteptarea Suma împotriva revendicării cheltuieli {1}. În așteptarea Suma este {2}
 DocType: Maintenance Schedule,Schedule,Program
 DocType: Account,Parent Account,Contul părinte
 DocType: Quality Inspection Reading,Reading 3,Reading 3
 ,Hub,Butuc
 DocType: GL Entry,Voucher Type,Tip Voucher
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1316,Price List not found or disabled,Lista de preturi nu a fost găsit sau cu handicap
+apps/erpnext/erpnext/accounts/page/pos/pos.js +1563,Price List not found or disabled,Lista de preturi nu a fost găsit sau cu handicap
 DocType: Employee Loan Application,Approved,Aprobat
 DocType: Pricing Rule,Price,Preț
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +248,Employee relieved on {0} must be set as 'Left',Angajat eliberat din finctie pe {0} trebuie să fie setat ca 'Plecat'
+apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +261,Employee relieved on {0} must be set as 'Left',Angajat eliberat din finctie pe {0} trebuie să fie setat ca 'Plecat'
 DocType: Item,"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.","Selectând ""Da"", va da o identitate unică pentru fiecare entitate din acest articol, care poate fi vizualizat în ordine maestru."
 DocType: Guardian,Guardian,gardian
 apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Expertiza {0} creată pentru angajatul {1} în intervalul de timp dat
@@ -4142,7 +4416,7 @@
 DocType: Delivery Note Item,Available Qty at From Warehouse,Cantitate Disponibil la Depozitul
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +295,Please select Employee Record first.,Vă rugăm să selectați Angajat Înregistrare întâi.
 DocType: POS Profile,Account for Change Amount,Contul pentru Schimbare Sumă
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +210,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Rând {0}: Parte / conturi nu se potrivește cu {1} / {2} din {3} {4}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +205,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Rând {0}: Parte / conturi nu se potrivește cu {1} / {2} din {3} {4}
 apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Va rugam sa introduceti cont de cheltuieli
 DocType: Account,Stock,Stoc
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +984,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Rând # {0}: Tip document de referință trebuie să fie unul dintre comandă cumparare, factură sau Jurnal de intrare"
@@ -4163,11 +4437,11 @@
 DocType: Stock Entry,Default Target Warehouse,Depozit Tinta Implicit
 DocType: Purchase Invoice,Net Total (Company Currency),Net total (Compania de valuta)
 apps/erpnext/erpnext/schools/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,Anul Data de încheiere nu poate fi mai devreme decât data An Start. Vă rugăm să corectați datele și încercați din nou.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +98,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Row {0}: Partidul Tip și Partidul se aplică numai împotriva creanțe / cont de plati
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +93,Row {0}: Party Type and Party is only applicable against Receivable / Payable account,Row {0}: Partidul Tip și Partidul se aplică numai împotriva creanțe / cont de plati
 DocType: Notification Control,Purchase Receipt Message,Primirea de cumpărare Mesaj
 DocType: BOM,Scrap Items,resturi Articole
 DocType: Production Order,Actual Start Date,Dată Efectivă de Început
-DocType: Sales Order,% of materials delivered against this Sales Order,% 재료가 이 주문을 위해 입고됨
+DocType: Sales Order,% of materials delivered against this Sales Order,% de materiale livrate versus comanda aceasta
 apps/erpnext/erpnext/config/stock.py +12,Record item movement.,Mișcare element înregistrare.
 DocType: Training Event Employee,Withdrawn,retrasă
 DocType: Hub Settings,Hub Settings,Setări Hub
@@ -4183,7 +4457,7 @@
 apps/erpnext/erpnext/accounts/doctype/asset/asset.js +260,Transfer Asset,activ de transfer
 DocType: POS Profile,POS Profile,POS Profil
 DocType: Training Event,Event Name,Numele evenimentului
-apps/erpnext/erpnext/config/schools.py +36,Admission,Admitere
+apps/erpnext/erpnext/config/schools.py +43,Admission,Admitere
 apps/erpnext/erpnext/schools/doctype/student_admission/student_admission.py +26,Admissions for {0},Admitere pentru {0}
 apps/erpnext/erpnext/config/accounts.py +221,"Seasonality for setting budgets, targets etc.","Sezonalitatea pentru stabilirea bugetelor, obiective etc."
 apps/erpnext/erpnext/stock/get_item_details.py +128,"Item {0} is a template, please select one of its variants","Postul {0} este un șablon, vă rugăm să selectați unul dintre variantele sale"
@@ -4194,8 +4468,9 @@
 DocType: Assessment Plan,Room,Cameră
 DocType: Purchase Order,Advance Paid,Avans plătit
 DocType: Item,Item Tax,Taxa Articol
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +747,Material to Supplier,Material de Furnizor
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +360,Excise Invoice,Accize factură
+apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +798,Material to Supplier,Material de Furnizor
+apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +362,Excise Invoice,Accize factură
+apps/erpnext/erpnext/schools/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Treshold {0}% apare mai mult decât o dată
 DocType: Expense Claim,Employees Email Id,Id Email Angajat
 DocType: Employee Attendance Tool,Marked Attendance,Participarea marcat
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +136,Current Liabilities,Raspunderi Curente
@@ -4204,6 +4479,7 @@
 DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Considerare Taxa sau Cost pentru
 apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Cantitatea efectivă este obligatorie
 apps/erpnext/erpnext/schools/doctype/student_group_creation_tool/student_group_creation_tool.py +48,Student Groups created.,Grupurile create de studenți.
+DocType: Employee Loan,Loan Type,Tip credit
 DocType: Scheduling Tool,Scheduling Tool,Instrumentul de programare
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +142,Credit Card,Card de Credit
 DocType: BOM,Item to be manufactured or repacked,Articol care urmează să fie fabricat sau reambalat
@@ -4222,8 +4498,9 @@
 apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Trebuie să salvați formularul înainte de a începe
 DocType: Item Attribute,Numeric Values,Valori numerice
 apps/erpnext/erpnext/public/js/setup_wizard.js +177,Attach Logo,Atașați logo
+apps/erpnext/erpnext/stock/doctype/item/item.js +239,Stock Levels,Niveluri stoc
 DocType: Customer,Commission Rate,Rata de Comision
-apps/erpnext/erpnext/stock/doctype/item/item.js +285,Make Variant,Face Varianta
+apps/erpnext/erpnext/stock/doctype/item/item.js +323,Make Variant,Face Varianta
 apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Blocaţi cereri de concediu pe departamente.
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +125,"Payment Type must be one of Receive, Pay and Internal Transfer","Tipul de plată trebuie să fie unul dintre Primire, Pay și de transfer intern"
 apps/erpnext/erpnext/config/selling.py +179,Analytics,Google Analytics
@@ -4232,6 +4509,7 @@
 DocType: Production Order,Actual Operating Cost,Cost efectiv de operare
 DocType: Payment Entry,Cheque/Reference No,Cecul / de referință nr
 apps/erpnext/erpnext/accounts/doctype/account/account.py +85,Root cannot be edited.,Rădăcină nu poate fi editat.
+DocType: Item,Units of Measure,Unitati de masura
 DocType: Manufacturing Settings,Allow Production on Holidays,Permiteţi operaţii de producție pe durata sărbătorilor
 DocType: Sales Order,Customer's Purchase Order Date,Data Comanda de Aprovizionare Client
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +161,Capital Stock,Capital Stock
@@ -4240,12 +4518,13 @@
 DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,După finalizarea plății de redirecționare utilizator la pagina selectată.
 DocType: Company,Existing Company,companie existentă
 apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Vă rugăm să selectați un fișier csv
+DocType: Student Leave Application,Mark as Present,Marcați ca prezent
 DocType: Purchase Order,To Receive and Bill,Pentru a primi și Bill
 apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Produse recomandate
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +98,Designer,Proiectant
 apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Termeni și condiții Format
 DocType: Serial No,Delivery Details,Detalii Livrare
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +476,Cost Center is required in row {0} in Taxes table for type {1},Centrul de Cost este necesar pentru inregistrarea {0} din tabelul Taxe pentru tipul {1}
+apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +484,Cost Center is required in row {0} in Taxes table for type {1},Centrul de Cost este necesar pentru inregistrarea {0} din tabelul Taxe pentru tipul {1}
 DocType: Program,Program Code,Codul programului
 DocType: Terms and Conditions,Terms and Conditions Help,Termeni și Condiții Ajutor
 ,Item-wise Purchase Register,Registru Achizitii Articol-Avizat
@@ -4260,21 +4539,23 @@
 DocType: Supplier,Credit Days,Zile de Credit
 DocType: Student Batch Creation Tool,Make Student Batch,Asigurați-Lot Student
 DocType: Leave Type,Is Carry Forward,Este Carry Forward
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +727,Get Items from BOM,Obține articole din FDM
+apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +778,Get Items from BOM,Obține articole din FDM
 apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Timpul in Zile Conducere
 apps/erpnext/erpnext/controllers/accounts_controller.py +562,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Rând # {0}: Detașarea Data trebuie să fie aceeași ca dată de achiziție {1} din activ {2}
 apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +129,Please enter Sales Orders in the above table,Vă rugăm să introduceți comenzile de vânzări în tabelul de mai sus
+apps/erpnext/erpnext/hr/doctype/process_payroll/process_payroll.py +186,Not Submitted Salary Slips,Netrimisă salariale Alunecările
 ,Stock Summary,Rezumat de stoc
 apps/erpnext/erpnext/config/accounts.py +236,Transfer an asset from one warehouse to another,Se transferă un activ de la un depozit la altul
 DocType: Vehicle,Petrol,Benzină
 apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Proiect de lege de materiale
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +96,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Partidul Tipul și Partidul este necesar pentru creanțe / cont plateste {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +91,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Row {0}: Partidul Tipul și Partidul este necesar pentru creanțe / cont plateste {1}
 apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Ref Data
 DocType: Employee,Reason for Leaving,Motiv pentru Lăsând
 DocType: BOM Operation,Operating Cost(Company Currency),Costul de operare (Companie Moneda)
+DocType: Employee Loan Application,Rate of Interest,Rata dobânzii
 DocType: Expense Claim Detail,Sanctioned Amount,Sancționate Suma
 DocType: GL Entry,Is Opening,Se deschide
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +189,Row {0}: Debit entry can not be linked with a {1},Rând {0}: debit de intrare nu poate fi legat de o {1}
+apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +184,Row {0}: Debit entry can not be linked with a {1},Rând {0}: debit de intrare nu poate fi legat de o {1}
 apps/erpnext/erpnext/accounts/doctype/account/account.py +234,Account {0} does not exist,Contul {0} nu există
 DocType: Account,Cash,Numerar
 DocType: Employee,Short biography for website and other publications.,Scurta biografie pentru site-ul web și alte publicații.
